@lota-sdk/core 0.4.8 → 0.4.10

package/src/services/social-chat-history.service.ts

@@ -1,13 +1,58 @@
+import { normalizeMessageBatch } from '@lota-sdk/shared'
+import { Context, Effect, Layer, Schema } from 'effect'
 import { z } from 'zod'
 
-import { getRedisConnection } from '../redis'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { RedisServiceTag, RuntimeConfigServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from '../redis/connection'
+import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { LotaRuntimeBackgroundCursor, LotaRuntimeBackgroundCursorKind } from '../runtime/runtime-extensions'
 
+export class SocialChatHistoryError extends Schema.TaggedErrorClass<SocialChatHistoryError>()(
+  'SocialChatHistoryError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+const tryRedisPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new SocialChatHistoryError({ message, cause }),
+)
+
 const DEFAULT_SOCIAL_CHAT_HISTORY_PREFIX = 'lota:social:history'
 
 const SocialChatMessageRoleSchema = z.enum(['user', 'assistant'])
 const SocialChatSourceSchema = z.literal('social')
 const SocialChatPlatformSchema = z.literal('slack')
+const SocialChatHistoryGenericPartSchema = z
+  .object({ type: z.string().optional(), text: z.string().optional() })
+  .catchall(z.unknown())
+const SocialChatHistoryTextPartSchema = SocialChatHistoryGenericPartSchema.extend({
+  type: z.literal('text'),
+  text: z.string().trim().min(1),
+})
+const SocialChatHistoryFilePartSchema = SocialChatHistoryGenericPartSchema.extend({
+  type: z.literal('file'),
+  filename: z.string().trim().min(1),
+  mediaType: z.string().trim().min(1),
+  sizeBytes: z.number().int().nonnegative().nullable(),
+  storageKey: z.string().trim().min(1),
+})
+const SocialChatHistoryPartSchema = z.union([
+  SocialChatHistoryTextPartSchema,
+  SocialChatHistoryFilePartSchema,
+  SocialChatHistoryGenericPartSchema,
+])
+const SocialChatHistoryMetadataSchema = z
+  .object({
+    platform: SocialChatPlatformSchema,
+    channelId: z.string().trim().min(1),
+    threadId: z.string().trim().min(1),
+    messageId: z.string().trim().min(1),
+    authorId: z.string().trim().min(1).optional(),
+    authorName: z.string().trim().min(1).optional(),
+    agentId: z.string().trim().min(1).optional(),
+    agentName: z.string().trim().min(1).optional(),
+  })
+  .catchall(z.unknown())
 
 const SocialChatHistoryMessageSchema = z.object({
   source: SocialChatSourceSchema,
@@ -18,15 +63,17 @@ const SocialChatHistoryMessageSchema = z.object({
   threadId: z.string().trim().min(1),
   messageId: z.string().trim().min(1),
   role: SocialChatMessageRoleSchema,
-  parts: z.array(z.record(z.string(), z.unknown())),
-  metadata: z.record(z.string(), z.unknown()).optional(),
+  parts: z.array(SocialChatHistoryPartSchema),
+  metadata: SocialChatHistoryMetadataSchema.optional(),
   cursor: z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) }),
 })
+const SocialChatHistoryCursorSchema = z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) })
+const decodeJsonStringEffect = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)
 
+export type SocialChatHistoryPart = z.infer<typeof SocialChatHistoryPartSchema>
+export type SocialChatHistoryMetadata = z.infer<typeof SocialChatHistoryMetadataSchema>
 export type SocialChatHistoryMessage = z.infer<typeof SocialChatHistoryMessageSchema>
 
-let socialChatHistoryPrefix = DEFAULT_SOCIAL_CHAT_HISTORY_PREFIX
-
 function trimConfiguredPrefix(value: string | undefined): string {
   const normalized = value?.trim()
   return normalized && normalized.length > 0 ? normalized : DEFAULT_SOCIAL_CHAT_HISTORY_PREFIX
@@ -38,160 +85,181 @@ function compareCursorOrder(left: LotaRuntimeBackgroundCursor, right: LotaRuntim
   return left.id.localeCompare(right.id)
 }
 
-class SocialChatHistoryService {
-  configure(params?: { keyPrefix?: string }): void {
-    socialChatHistoryPrefix = trimConfiguredPrefix(params?.keyPrefix)
-  }
+export function makeSocialChatHistoryService(
+  redis: RedisConnectionManager,
+  config: ResolvedLotaRuntimeConfig | undefined,
+) {
+  const resolvePrefix = (): string => trimConfiguredPrefix(config?.socialChat?.historyRedisKeyPrefix)
 
-  private messageStorageKey(message: {
+  const messageStorageKey = (message: {
     platform: 'slack'
     workspaceId: string
     threadId: string
     messageId: string
-  }): string {
-    return `${socialChatHistoryPrefix}:message:${message.platform}:${message.workspaceId}:${message.threadId}:${message.messageId}`
-  }
+  }): string =>
+    `${resolvePrefix()}:message:${message.platform}:${message.workspaceId}:${message.threadId}:${message.messageId}`
 
-  private threadIndexKey(workspaceId: string, threadId: string): string {
-    return `${socialChatHistoryPrefix}:thread:${workspaceId}:${threadId}`
-  }
+  const threadIndexKey = (workspaceId: string, threadId: string): string =>
+    `${resolvePrefix()}:thread:${workspaceId}:${threadId}`
 
-  private workspaceIndexKey(workspaceId: string): string {
-    return `${socialChatHistoryPrefix}:workspace:${workspaceId}`
-  }
+  const workspaceIndexKey = (workspaceId: string): string => `${resolvePrefix()}:workspace:${workspaceId}`
 
-  private cursorKey(kind: LotaRuntimeBackgroundCursorKind, workspaceId: string): string {
-    return `${socialChatHistoryPrefix}:cursor:${kind}:${workspaceId}`
-  }
+  const cursorKey = (kind: LotaRuntimeBackgroundCursorKind, workspaceId: string): string =>
+    `${resolvePrefix()}:cursor:${kind}:${workspaceId}`
 
-  private serializeMessage(message: SocialChatHistoryMessage): string {
-    return JSON.stringify({
-      ...message,
-      cursor: { ...message.cursor, createdAt: message.cursor.createdAt.toISOString() },
-    })
-  }
+  const serializeMessage = (message: SocialChatHistoryMessage): string =>
+    JSON.stringify({ ...message, cursor: { ...message.cursor, createdAt: message.cursor.createdAt.toISOString() } })
 
-  private parseStoredMessage(value: string | null): SocialChatHistoryMessage | null {
-    if (!value) return null
-    try {
-      const parsed = SocialChatHistoryMessageSchema.safeParse(JSON.parse(value))
-      return parsed.success ? parsed.data : null
-    } catch {
-      return null
-    }
-  }
+  const parseStoredMessageEffect = (value: string | null): Effect.Effect<SocialChatHistoryMessage | null> => {
+    if (!value) return Effect.succeed(null)
 
-  private serializeCursor(cursor: LotaRuntimeBackgroundCursor): string {
-    return JSON.stringify({ ...cursor, createdAt: cursor.createdAt.toISOString() })
+    return decodeJsonStringEffect(value).pipe(
+      Effect.map((parsed) => {
+        const validated = SocialChatHistoryMessageSchema.safeParse(parsed)
+        return validated.success ? validated.data : null
+      }),
+      Effect.catch(() => Effect.succeed(null)),
+    )
   }
 
-  private parseCursor(value: string | null): LotaRuntimeBackgroundCursor | null {
-    if (!value) return null
-    try {
-      const parsed = z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) }).safeParse(JSON.parse(value))
-      return parsed.success ? parsed.data : null
-    } catch {
-      return null
-    }
+  const serializeCursor = (cursor: LotaRuntimeBackgroundCursor): string =>
+    JSON.stringify({ ...cursor, createdAt: cursor.createdAt.toISOString() })
+
+  const parseCursorEffect = (value: string | null): Effect.Effect<LotaRuntimeBackgroundCursor | null> => {
+    if (!value) return Effect.succeed(null)
+
+    return decodeJsonStringEffect(value).pipe(
+      Effect.map((parsed) => {
+        const validated = SocialChatHistoryCursorSchema.safeParse(parsed)
+        return validated.success ? validated.data : null
+      }),
+      Effect.catch(() => Effect.succeed(null)),
+    )
   }
 
-  async upsertMessages(messages: SocialChatHistoryMessage[]): Promise<SocialChatHistoryMessage[]> {
-    if (messages.length === 0) return []
+  const upsertMessagesEffect = (messages: SocialChatHistoryMessage[]) =>
+    Effect.gen(function* () {
+      if (messages.length === 0) return [] as SocialChatHistoryMessage[]
 
-    const redis = getRedisConnection()
-    const normalizedMessages = messages.map((message) => SocialChatHistoryMessageSchema.parse(message))
-    const multi = redis.multi()
+      const conn = redis.getConnection()
+      const normalizedMessages = normalizeMessageBatch(messages, {
+        parseMessage: (message) => SocialChatHistoryMessageSchema.parse(message),
+        compareMessages: (left, right) => compareCursorOrder(left.cursor, right.cursor),
+        getMessageId: (message) => message.messageId,
+      })
+      const multi = conn.multi()
 
-    for (const message of normalizedMessages) {
-      const storageKey = this.messageStorageKey(message)
-      const score = message.cursor.createdAt.getTime()
-      multi.set(storageKey, this.serializeMessage(message))
-      multi.zadd(this.threadIndexKey(message.workspaceId, message.threadId), score, storageKey)
-      multi.zadd(this.workspaceIndexKey(message.workspaceId), score, storageKey)
-    }
+      for (const message of normalizedMessages) {
+        const storageKey = messageStorageKey(message)
+        const score = message.cursor.createdAt.getTime()
+        multi.set(storageKey, serializeMessage(message))
+        multi.zadd(threadIndexKey(message.workspaceId, message.threadId), score, storageKey)
+        multi.zadd(workspaceIndexKey(message.workspaceId), score, storageKey)
+      }
 
-    await multi.exec()
-    return normalizedMessages
-  }
+      yield* tryRedisPromise(() => multi.exec(), 'Failed to upsert social chat messages.')
+      return normalizedMessages
+    })
 
-  async listThreadMessages(params: { workspaceId: string; threadId: string }): Promise<SocialChatHistoryMessage[]> {
-    const redis = getRedisConnection()
-    const storageKeys = await redis.zrange(this.threadIndexKey(params.workspaceId, params.threadId), 0, -1)
-    if (storageKeys.length === 0) return []
+  const listThreadMessagesEffect = (params: { workspaceId: string; threadId: string }) =>
+    Effect.gen(function* () {
+      const conn = redis.getConnection()
+      const storageKeys = yield* tryRedisPromise(
+        () => conn.zrange(threadIndexKey(params.workspaceId, params.threadId), 0, -1),
+        'Failed to list thread message keys.',
+      )
+      if (storageKeys.length === 0) return [] as SocialChatHistoryMessage[]
 
-    const storedValues = await redis.mget(storageKeys)
-    return storedValues
-      .map((value) => this.parseStoredMessage(value))
-      .filter((message): message is SocialChatHistoryMessage => message !== null)
-      .sort((left, right) => compareCursorOrder(left.cursor, right.cursor))
-  }
+      const storedValues = yield* tryRedisPromise(() => conn.mget(storageKeys), 'Failed to read thread messages.')
+      const parsedMessages = yield* Effect.forEach(storedValues, parseStoredMessageEffect)
+      return parsedMessages
+        .filter((message): message is SocialChatHistoryMessage => message !== null)
+        .sort((left, right) => compareCursorOrder(left.cursor, right.cursor))
+    })
 
-  async listWorkspaceMessages(params: {
+  const listWorkspaceMessagesEffect = (params: {
     workspaceId: string
     cursor: LotaRuntimeBackgroundCursor | null
     onboardingCutoff: Date | null
-  }): Promise<SocialChatHistoryMessage[]> {
-    const redis = getRedisConnection()
-    const indexKey = this.workspaceIndexKey(params.workspaceId)
-    const scoreStart =
-      params.cursor?.createdAt.getTime() ??
-      (params.onboardingCutoff ? params.onboardingCutoff.getTime() : Number.NEGATIVE_INFINITY)
-    const storageKeys =
-      params.cursor || params.onboardingCutoff
-        ? await redis.zrangebyscore(indexKey, scoreStart, '+inf')
-        : await redis.zrange(indexKey, 0, -1)
-
-    if (storageKeys.length === 0) return []
-
-    const storedValues = await redis.mget(storageKeys)
-    return storedValues
-      .map((value) => this.parseStoredMessage(value))
-      .filter((message): message is SocialChatHistoryMessage => message !== null)
-      .filter((message) => {
-        if (params.cursor) {
-          return compareCursorOrder(message.cursor, params.cursor) > 0
-        }
-        if (params.onboardingCutoff) {
-          return message.cursor.createdAt.getTime() > params.onboardingCutoff.getTime()
-        }
-        return true
-      })
-      .sort((left, right) => compareCursorOrder(left.cursor, right.cursor))
-  }
+  }) =>
+    Effect.gen(function* () {
+      const conn = redis.getConnection()
+      const indexKey = workspaceIndexKey(params.workspaceId)
+      const scoreStart =
+        params.cursor?.createdAt.getTime() ??
+        (params.onboardingCutoff ? params.onboardingCutoff.getTime() : Number.NEGATIVE_INFINITY)
+      const storageKeys = yield* tryRedisPromise(
+        () =>
+          params.cursor || params.onboardingCutoff
+            ? conn.zrangebyscore(indexKey, scoreStart, '+inf')
+            : conn.zrange(indexKey, 0, -1),
+        'Failed to list workspace message keys.',
+      )
+      if (storageKeys.length === 0) return [] as SocialChatHistoryMessage[]
+
+      const storedValues = yield* tryRedisPromise(() => conn.mget(storageKeys), 'Failed to read workspace messages.')
+      const parsedMessages = yield* Effect.forEach(storedValues, parseStoredMessageEffect)
+      return parsedMessages
+        .filter((message): message is SocialChatHistoryMessage => message !== null)
+        .filter((message) => {
+          if (params.cursor) {
+            return compareCursorOrder(message.cursor, params.cursor) > 0
+          }
+          if (params.onboardingCutoff) {
+            return message.cursor.createdAt.getTime() > params.onboardingCutoff.getTime()
+          }
+          return true
+        })
+        .sort((left, right) => compareCursorOrder(left.cursor, right.cursor))
+    })
 
-  async hasWorkspaceMessages(params: {
+  const hasWorkspaceMessagesEffect = (params: {
     workspaceId: string
     cursor: LotaRuntimeBackgroundCursor | null
     onboardingCutoff: Date | null
-  }): Promise<boolean> {
-    const messages = await this.listWorkspaceMessages({
+  }) =>
+    listWorkspaceMessagesEffect({
       workspaceId: params.workspaceId,
       cursor: params.cursor,
       onboardingCutoff: params.onboardingCutoff,
-    })
-    return messages.length > 0
-  }
+    }).pipe(Effect.map((messages) => messages.length > 0))
 
-  async getBackgroundCursor(
-    kind: LotaRuntimeBackgroundCursorKind,
-    workspaceId: string,
-  ): Promise<LotaRuntimeBackgroundCursor | null> {
-    const redis = getRedisConnection()
-    return this.parseCursor(await redis.get(this.cursorKey(kind, workspaceId)))
-  }
+  const getBackgroundCursorEffect = (kind: LotaRuntimeBackgroundCursorKind, workspaceId: string) =>
+    tryRedisPromise(
+      () => redis.getConnection().get(cursorKey(kind, workspaceId)),
+      'Failed to read background cursor.',
+    ).pipe(Effect.flatMap((value) => parseCursorEffect(value)))
 
-  async setBackgroundCursor(
+  const setBackgroundCursorEffect = (
     kind: LotaRuntimeBackgroundCursorKind,
     workspaceId: string,
     cursor: LotaRuntimeBackgroundCursor,
-  ): Promise<void> {
-    const redis = getRedisConnection()
-    await redis.set(this.cursorKey(kind, workspaceId), this.serializeCursor(cursor))
+  ) =>
+    tryRedisPromise(
+      () => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor)),
+      'Failed to write background cursor.',
+    ).pipe(Effect.asVoid)
+
+  return {
+    upsertMessages: upsertMessagesEffect,
+    listThreadMessages: listThreadMessagesEffect,
+    listWorkspaceMessages: listWorkspaceMessagesEffect,
+    hasWorkspaceMessages: hasWorkspaceMessagesEffect,
+    getBackgroundCursor: getBackgroundCursorEffect,
+    setBackgroundCursor: setBackgroundCursorEffect,
   }
 }
 
-export const socialChatHistoryService = new SocialChatHistoryService()
+export class SocialChatHistoryServiceTag extends Context.Service<
+  SocialChatHistoryServiceTag,
+  ReturnType<typeof makeSocialChatHistoryService>
+>()('@lota-sdk/core/SocialChatHistoryService') {}
 
-export function configureSocialChatHistory(params?: { keyPrefix?: string }): void {
-  socialChatHistoryService.configure(params)
-}
+export const SocialChatHistoryServiceLive = Layer.effect(
+  SocialChatHistoryServiceTag,
+  Effect.gen(function* () {
+    const redis = yield* RedisServiceTag
+    const config = yield* RuntimeConfigServiceTag
+    return makeSocialChatHistoryService(redis, config)
+  }),
+)

package/src/services/system-executor.service.ts

@@ -1,27 +1,38 @@
 import type { OwnershipDispatchContext, PlanNodeResult, PlanNodeSpec, SystemPlanNodeOwner } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
 
+import { BadRequestError, ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { RuntimeConfigServiceTag } from '../effect/services'
+
+const trySystemExecutorPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ServiceError({ message, cause }),
+)
 import type { SystemNodeExecutor, PluginNodeExecutionParams } from '../runtime/plugin-types'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-import type { PlanValidationIssueInput } from './plan-validator.service'
+import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan/plan-validator.service'
 
 const BUILT_IN_SYSTEM_EXECUTORS = Object.freeze({
   'plan-runtime': {
     supportedOperations: ['echo-input'],
-    async executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult> {
-      return { notes: 'System echo-input completed.', structuredOutput: structuredClone(params.inputs), artifacts: [] }
+    executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult> {
+      return Promise.resolve({
+        notes: 'System echo-input completed.',
+        structuredOutput: structuredClone(params.inputs),
+        artifacts: [],
+      })
     },
   } satisfies SystemNodeExecutor,
 })
 
-export function getBuiltInSystemExecutors(): Record<string, SystemNodeExecutor> {
-  return Object.fromEntries(Object.entries(BUILT_IN_SYSTEM_EXECUTORS))
+function isSystemOwner(
+  owner: PlanNodeSpec['owner'],
+): owner is Extract<PlanNodeSpec['owner'], { executorType: 'system' }> {
+  return owner.executorType === 'system'
 }
 
-function getSystemExecutors() {
-  return (getRuntimeConfig().systemExecutors ?? getBuiltInSystemExecutors()) as Record<
-    string,
-    SystemNodeExecutor | undefined
-  >
+export function getBuiltInSystemExecutors(): Record<string, SystemNodeExecutor> {
+  return Object.fromEntries(Object.entries(BUILT_IN_SYSTEM_EXECUTORS))
 }
 
 function buildSystemExecutionParams(params: {
@@ -45,61 +56,85 @@ function buildSystemExecutionParams(params: {
   }
 }
 
-class SystemExecutorService {
-  validateOwner(owner: SystemPlanNodeOwner, nodeId: string): PlanValidationIssueInput[] {
-    const executor = getSystemExecutors()[owner.ref]
-    if (!executor) {
-      return [
-        {
-          severity: 'blocking',
-          code: 'system_executor_missing',
-          message: `Node "${nodeId}" references unknown system executor "${owner.ref}".`,
-          nodeId,
-          detail: { systemRef: owner.ref },
-        },
-      ]
-    }
+export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
+  function getSystemExecutors() {
+    return (config.systemExecutors ?? getBuiltInSystemExecutors()) as Record<string, SystemNodeExecutor | undefined>
+  }
 
-    if (!executor.supportedOperations.includes(owner.operation)) {
-      return [
-        {
-          severity: 'blocking',
-          code: 'system_operation_missing',
-          message: `System executor "${owner.ref}" does not support operation "${owner.operation}".`,
-          nodeId,
-          detail: { systemRef: owner.ref, operation: owner.operation },
-        },
-      ]
-    }
+  return {
+    validateOwner(owner: SystemPlanNodeOwner, nodeId: string): PlanValidationIssueInput[] {
+      const executor = getSystemExecutors()[owner.ref]
+      if (!executor) {
+        return [
+          {
+            severity: 'blocking',
+            code: 'system_executor_missing',
+            message: `Node "${nodeId}" references unknown system executor "${owner.ref}".`,
+            nodeId,
+            detail: { systemRef: owner.ref },
+          },
+        ]
+      }
 
-    return []
-  }
+      if (!executor.supportedOperations.includes(owner.operation)) {
+        return [
+          {
+            severity: 'blocking',
+            code: 'system_operation_missing',
+            message: `System executor "${owner.ref}" does not support operation "${owner.operation}".`,
+            nodeId,
+            detail: { systemRef: owner.ref, operation: owner.operation },
+          },
+        ]
+      }
 
-  async executeNode(params: {
-    nodeSpec: PlanNodeSpec
-    resolvedInput: Record<string, unknown>
-    context: OwnershipDispatchContext
-  }): Promise<PlanNodeResult> {
-    if (params.nodeSpec.owner.executorType !== 'system') {
-      throw new Error(`SystemExecutor cannot execute owner type "${params.nodeSpec.owner.executorType}".`)
-    }
+      return []
+    },
 
-    const executor = getSystemExecutors()[params.nodeSpec.owner.ref]
-    if (!executor || !executor.supportedOperations.includes(params.nodeSpec.owner.operation)) {
-      throw new Error(
-        `System executor ${params.nodeSpec.owner.ref}.${params.nodeSpec.owner.operation} is not registered.`,
-      )
-    }
+    executeNode: Effect.fn('SystemExecutor.executeNode')(function* (params: {
+      nodeSpec: PlanNodeSpec
+      resolvedInput: Record<string, unknown>
+      context: OwnershipDispatchContext
+    }) {
+      const owner = params.nodeSpec.owner
+      if (!isSystemOwner(owner)) {
+        return yield* new BadRequestError({
+          message: `SystemExecutor cannot execute owner type "${owner.executorType}".`,
+        })
+      }
 
-    return executor.executeNode(
-      buildSystemExecutionParams({
-        owner: params.nodeSpec.owner,
-        nodeSpec: params.nodeSpec,
-        resolvedInput: params.resolvedInput,
-        context: params.context,
-      }),
-    )
+      const executor = getSystemExecutors()[owner.ref]
+      if (!executor || !executor.supportedOperations.includes(owner.operation)) {
+        return yield* new BadRequestError({
+          message: `System executor ${owner.ref}.${owner.operation} is not registered.`,
+        })
+      }
+
+      return yield* trySystemExecutorPromise(
+        () =>
+          executor.executeNode(
+            buildSystemExecutionParams({
+              owner,
+              nodeSpec: params.nodeSpec,
+              resolvedInput: params.resolvedInput,
+              context: params.context,
+            }),
+          ),
+        `System executor "${owner.ref}.${owner.operation}" failed.`,
+      ).pipe(Effect.withSpan('SystemExecutor.invoke'))
+    }),
   }
 }
 
-export const systemExecutorService = new SystemExecutorService()
+export class SystemExecutorServiceTag extends Context.Service<
+  SystemExecutorServiceTag,
+  ReturnType<typeof makeSystemExecutorService>
+>()('@lota-sdk/core/SystemExecutorService') {}
+
+export const SystemExecutorServiceLive = Layer.effect(
+  SystemExecutorServiceTag,
+  Effect.gen(function* () {
+    const runtimeConfig = yield* RuntimeConfigServiceTag
+    return makeSystemExecutorService(runtimeConfig)
+  }),
+)