@lota-sdk/core 0.4.13 → 0.4.15

package/src/workers/skill-extraction.runner.ts

@@ -1,6 +1,7 @@
-import type { Context, Cause } from 'effect'
-import { Effect } from 'effect'
+import { Cause, Effect } from 'effect'
+import type { Context } from 'effect'
 
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
@@ -8,16 +9,15 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { effectTryPromise } from '../effect/helpers'
 import { ProviderEmbeddings } from '../embeddings/provider'
 import type { SkillExtractionJob } from '../queues/organization-learning.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import type { LotaRuntimeAdapters } from '../runtime/runtime-extensions'
 import type { LearnedSkillServiceTag } from '../services/learned-skill.service'
 import type { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
-import { createSkillExtractorAgent, SkillExtractionOutputSchema } from '../system-agents/skill-extractor.agent'
+import { makeSkillExtractorAgentFactory, SkillExtractionOutputSchema } from '../system-agents/skill-extractor.agent'
 import type { SkillCandidate } from '../system-agents/skill-extractor.agent'
-import { createSkillManagerAgent, SkillManagerOutputSchema } from '../system-agents/skill-manager.agent'
+import { makeSkillManagerAgentFactory, SkillManagerOutputSchema } from '../system-agents/skill-manager.agent'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
 import {
   compareDigestMessageOrder,
@@ -30,12 +30,14 @@ const MIN_MESSAGE_THRESHOLD = 10
 
 export interface SkillExtractionServices {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   databaseService: SurrealDBService
   learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
   runtimeAdapters: LotaRuntimeAdapters
   embeddingModel: string
   openRouterApiKey?: string
+  runPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>
 }
 
 interface SkillExtractionRunResult {
@@ -110,21 +112,31 @@ function runSkillExtractionEffect(
   return Effect.gen(function* () {
     const getBackgroundCursor = cursorAwareWorkspaceProvider.getBackgroundCursor.bind(cursorAwareWorkspaceProvider)
     const setBackgroundCursor = cursorAwareWorkspaceProvider.setBackgroundCursor.bind(cursorAwareWorkspaceProvider)
-    const workspace = yield* effectTryPromise(() => cursorAwareWorkspaceProvider.getWorkspace(orgRef))
+    const workspace = yield* Effect.tryPromise({
+      try: () => cursorAwareWorkspaceProvider.getWorkspace(orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const lifecycleState = cursorAwareWorkspaceProvider.getLifecycleState
-      ? yield* effectTryPromise(() => Promise.resolve(cursorAwareWorkspaceProvider.getLifecycleState?.(workspace)))
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(cursorAwareWorkspaceProvider.getLifecycleState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping skill extraction for ${orgId}: onboarding is not completed`
       return { skipped: true, processedMessages: 0, extractedSkills: 0 }
     }
     const projectionState = cursorAwareWorkspaceProvider.readProfileProjectionState
-      ? yield* effectTryPromise(() =>
-          Promise.resolve(cursorAwareWorkspaceProvider.readProfileProjectionState?.(workspace)),
-        )
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(cursorAwareWorkspaceProvider.readProfileProjectionState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
 
-    const existingCursor = yield* effectTryPromise(() => getBackgroundCursor('skill-extraction', orgRef))
+    const existingCursor = yield* Effect.tryPromise({
+      try: () => getBackgroundCursor('skill-extraction', orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const onboardingCutoff = resolveWorkspaceBootstrapCutoff({
       hasExistingCursor: existingCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
@@ -135,10 +147,20 @@ function runSkillExtractionEffect(
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const threadIds = yield* effectTryPromise(() => listThreadIdsForOrg(services.databaseService, orgRef))
-    const threadMessages = yield* effectTryPromise(() =>
-      listEligibleThreadMessages({ db: services.databaseService, threadIds, cursor: existingCursor, onboardingCutoff }),
-    )
+    const threadIds = yield* Effect.tryPromise({
+      try: () => listThreadIdsForOrg(services.databaseService, orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+    const threadMessages = yield* Effect.tryPromise({
+      try: () =>
+        listEligibleThreadMessages({
+          db: services.databaseService,
+          threadIds,
+          cursor: existingCursor,
+          onboardingCutoff,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const socialMessages = yield* services.socialChatHistoryService.listWorkspaceMessages({
       workspaceId: orgId,
       cursor: existingSocialCursor,
@@ -163,24 +185,26 @@ function runSkillExtractionEffect(
         ? existingSkills.map((skill, i) => `${i + 1}. ${skill.name}: ${skill.description}`).join('\n')
         : 'None'
 
-    const extraction = yield* effectTryPromise(() =>
-      helperModelRuntime.generateHelperStructured({
-        tag: 'skill-extraction',
-        createAgent: createSkillExtractorAgent,
-        timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
-        messages: [
-          {
-            role: 'user',
-            content: buildExtractionPrompt({
-              workspaceName: projectionState?.workspaceName || 'Workspace',
-              transcript,
-              existingSkills: existingSkillsSummary,
-            }),
-          },
-        ],
-        schema: SkillExtractionOutputSchema,
-      }),
-    )
+    const extraction = yield* Effect.tryPromise({
+      try: () =>
+        helperModelRuntime.generateHelperStructured({
+          tag: 'skill-extraction',
+          createAgent: makeSkillExtractorAgentFactory(services.aiGatewayModels),
+          timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
+          messages: [
+            {
+              role: 'user',
+              content: buildExtractionPrompt({
+                workspaceName: projectionState?.workspaceName || 'Workspace',
+                transcript,
+                existingSkills: existingSkillsSummary,
+              }),
+            },
+          ],
+          schema: SkillExtractionOutputSchema,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
 
     const skillCandidates = extraction.candidates.filter((c) => c.classification === 'skill')
 
@@ -195,37 +219,42 @@ function runSkillExtractionEffect(
 
         const mostSimilar = yield* services.learnedSkillService.findMostSimilar(orgId, candidate.description)
 
-        const managerResult = yield* effectTryPromise(() =>
-          helperModelRuntime.generateHelperStructured({
-            tag: 'skill-manager',
-            createAgent: createSkillManagerAgent,
-            timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
-            messages: [
-              {
-                role: 'user',
-                content: buildManagerPrompt({
-                  candidate,
-                  existingSkill: mostSimilar
-                    ? {
-                        name: mostSimilar.name,
-                        description: mostSimilar.description,
-                        instructions: mostSimilar.instructions,
-                        version: mostSimilar.version,
-                      }
-                    : null,
-                }),
-              },
-            ],
-            schema: SkillManagerOutputSchema,
-          }),
-        )
+        const managerResult = yield* Effect.tryPromise({
+          try: () =>
+            helperModelRuntime.generateHelperStructured({
+              tag: 'skill-manager',
+              createAgent: makeSkillManagerAgentFactory(services.aiGatewayModels),
+              timeoutMs: SKILL_EXTRACTION_TIMEOUT_MS,
+              messages: [
+                {
+                  role: 'user',
+                  content: buildManagerPrompt({
+                    candidate,
+                    existingSkill: mostSimilar
+                      ? {
+                          name: mostSimilar.name,
+                          description: mostSimilar.description,
+                          instructions: mostSimilar.instructions,
+                          version: mostSimilar.version,
+                        }
+                      : null,
+                  }),
+                },
+              ],
+              schema: SkillManagerOutputSchema,
+            }),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
 
         if (managerResult.decision === 'discard') {
           serverLogger.info`Discarding skill candidate ${candidate.name}: ${managerResult.reason}`
           return 0
         }
 
-        const embedding = yield* effectTryPromise(() => embeddings.embedQuery(candidate.description))
+        const embedding = yield* Effect.tryPromise({
+          try: () => embeddings.embedQuery(candidate.description),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
         if (embedding.length === 0) {
           serverLogger.warn`Skipping skill candidate ${candidate.name}: empty embedding`
           return 0
@@ -253,7 +282,10 @@ function runSkillExtractionEffect(
         if (mostSimilar && managerResult.mergedSkill) {
           const merged = managerResult.mergedSkill
           const mergedHash = services.learnedSkillService.generateHash(merged.description, merged.instructions)
-          const mergedEmbedding = yield* effectTryPromise(() => embeddings.embedQuery(merged.description))
+          const mergedEmbedding = yield* Effect.tryPromise({
+            try: () => embeddings.embedQuery(merged.description),
+            catch: (cause) => new Cause.UnknownError(cause),
+          })
 
           yield* services.learnedSkillService.update(mostSimilar.id, {
             name: merged.name,
@@ -291,7 +323,10 @@ function runSkillExtractionEffect(
     const lastThreadMessage = threadMessages.at(-1)
     const lastSocialMessage = socialMessages.at(-1)
     if (lastThreadMessage) {
-      yield* effectTryPromise(() => setBackgroundCursor('skill-extraction', orgRef, lastThreadMessage.cursor))
+      yield* Effect.tryPromise({
+        try: () => setBackgroundCursor('skill-extraction', orgRef, lastThreadMessage.cursor),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }
     if (lastSocialMessage) {
       yield* services.socialChatHistoryService.setBackgroundCursor('skill-extraction', orgId, lastSocialMessage.cursor)
@@ -319,10 +354,11 @@ export function runSkillExtraction(
   const embeddings = new ProviderEmbeddings({
     modelId: services.embeddingModel,
     openRouterApiKey: services.openRouterApiKey,
+    runPromise: services.runPromise,
   })
   const withMemoryLock = runtimeAdapters.withWorkspaceMemoryLock
   const runExtraction = () =>
-    Effect.runPromise(
+    services.runPromise(
       runSkillExtractionEffect(services, orgRef, orgId, workspaceProvider, embeddings) as Effect.Effect<
         SkillExtractionRunResult,
         never,

package/src/workers/utils/repo-structure-extractor.ts

@@ -6,10 +6,8 @@ import type {
   RepositoryStructureSignal,
   RepositoryStructureSummary,
 } from '@lota-sdk/shared'
-import type { Cause } from 'effect'
-import { Effect } from 'effect'
+import { Cause, Effect } from 'effect'
 
-import { effectTryPromise } from '../../effect/helpers'
 import { nowIsoDateTimeString } from '../../utils/date-time'
 
 const EXTRACTOR_VERSION = 'repository-structure-extractor.v1'
@@ -152,14 +150,18 @@ function collectRelativeFilePathsEffect(
 ): Effect.Effect<string[], Cause.UnknownError, never> {
   return Effect.gen(function* () {
     const absoluteDir = currentDir ? joinPath(rootDir, currentDir) : rootDir
-    const entries = yield* effectTryPromise(() =>
-      Array.fromAsync(new Bun.Glob('*').scan({ cwd: absoluteDir, onlyFiles: false, absolute: false })),
-    )
+    const entries = yield* Effect.tryPromise({
+      try: () => Array.fromAsync(new Bun.Glob('*').scan({ cwd: absoluteDir, onlyFiles: false, absolute: false })),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
 
     const filePaths: string[] = []
     for (const entry of entries) {
       const relativePath = currentDir ? joinPath(currentDir, entry) : normalizePath(entry)
-      const stats = yield* effectTryPromise(() => Bun.file(joinPath(rootDir, relativePath)).stat())
+      const stats = yield* Effect.tryPromise({
+        try: () => Bun.file(joinPath(rootDir, relativePath)).stat(),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
 
       if (stats.isDirectory()) {
         if (IGNORED_DIR_NAMES.has(entry)) continue
@@ -179,7 +181,10 @@ function readPackageJsonEffect(
   rootDir: string,
   relativePath: string,
 ): Effect.Effect<PackageJson | null, Cause.UnknownError, never> {
-  return effectTryPromise(() => Bun.file(joinPath(rootDir, relativePath)).text()).pipe(
+  return Effect.tryPromise({
+    try: () => Bun.file(joinPath(rootDir, relativePath)).text(),
+    catch: (cause) => new Cause.UnknownError(cause),
+  }).pipe(
     Effect.map((raw) => {
       try {
         const parsed: unknown = JSON.parse(raw)

package/src/workers/utils/thread-message-query.ts

@@ -11,7 +11,7 @@ import { TABLES } from '../../db/tables'
 import { ThreadMessageRowSchema } from '../../db/thread-message-row'
 import type { ThreadMessageRow } from '../../db/thread-message-row'
 import { normalizeTextBody } from '../../document/parsing'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import type { LotaRuntimeBackgroundCursor } from '../../runtime/runtime-extensions'
 import type { SocialChatHistoryMessage } from '../../services/social-chat-history.service'
 import { unsafeDateFrom } from '../../utils/date-time'
@@ -53,10 +53,10 @@ function readPersistedMessageParts(parts: ThreadMessageRow['parts']): ChatMessag
   return (Array.isArray(parts) ? normalizeMessageValue(parts) : []) as ChatMessage['parts']
 }
 
-class ThreadMessageQueryError extends Schema.TaggedErrorClass<ThreadMessageQueryError>()('ThreadMessageQueryError', {
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class ThreadMessageQueryError extends Schema.TaggedErrorClass<ThreadMessageQueryError>()(
+  ERROR_TAGS.ThreadMessageQueryError,
+  { message: Schema.String, cause: Schema.Defect },
+) {}
 
 function mapThreadRow(row: ThreadMessageRow): ThreadDigestMessage {
   return {
@@ -72,10 +72,6 @@ function mapThreadRow(row: ThreadMessageRow): ThreadDigestMessage {
   }
 }
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ThreadMessageQueryError({ message, cause }),
-)
-
 export function compareDigestMessageOrder(left: DigestMessage, right: DigestMessage): number {
   const timeDiff = left.cursor.createdAt.getTime() - right.cursor.createdAt.getTime()
   if (timeDiff !== 0) return timeDiff
@@ -85,19 +81,20 @@ export function compareDigestMessageOrder(left: DigestMessage, right: DigestMess
 export function listThreadIdsForOrg(db: SurrealDBService, orgRef: RecordIdRef): Promise<RecordIdRef[]> {
   const EntityIdRowSchema = z.string().trim().min(1)
   return Effect.runPromise(
-    effectTryPromise(
-      () =>
-        db.query<unknown>(
-          new BoundQuery(
-            `SELECT VALUE type::string(id) FROM ${TABLES.THREAD}
+    db
+      .query<unknown>(
+        new BoundQuery(
+          `SELECT VALUE type::string(id) FROM ${TABLES.THREAD}
        WHERE organizationId = $organizationId`,
-            { organizationId: orgRef },
-          ),
+          { organizationId: orgRef },
+        ),
+      )
+      .pipe(
+        Effect.mapError(
+          (cause) => new ThreadMessageQueryError({ message: 'Failed to list thread ids for org digest.', cause }),
         ),
-      'Failed to list thread ids for org digest.',
-    ).pipe(
-      Effect.map((ids) => ids.map((value: unknown) => ensureRecordId(EntityIdRowSchema.parse(value), TABLES.THREAD))),
-    ),
+        Effect.map((ids) => ids.map((value: unknown) => ensureRecordId(EntityIdRowSchema.parse(value), TABLES.THREAD))),
+      ),
   )
 }
 
@@ -140,10 +137,13 @@ export function listEligibleThreadMessages(params: {
         return []
       }
 
-      const rows = yield* effectTryPromise(
-        () => params.db.query<unknown>(query),
-        'Failed to list eligible thread messages.',
-      )
+      const rows = yield* params.db
+        .query<unknown>(query)
+        .pipe(
+          Effect.mapError(
+            (cause) => new ThreadMessageQueryError({ message: 'Failed to list eligible thread messages.', cause }),
+          ),
+        )
       return rows.map((row: unknown) => mapThreadRow(ThreadMessageRowSchema.parse(row)))
     }),
   )

package/src/workers/worker-utils.ts

@@ -1,14 +1,20 @@
 import { fileURLToPath } from 'node:url'
 
 import type { Job, Worker } from 'bullmq'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 
 import { chatLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import type { QueueJobServiceTag } from '../services/queue-job.service'
 
 export type QueueJobService = Context.Service.Shape<typeof QueueJobServiceTag>
 
+class QueueWorkerError extends Schema.TaggedErrorClass<QueueWorkerError>()(ERROR_TAGS.QueueWorkerError, {
+  phase: Schema.Literals(['close', 'process', 'shutdown-timeout']),
+  cause: Schema.Defect,
+}) {}
+
 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 } }
 export const LONG_JOB_LOCK_DURATION_MS = 600_000
@@ -78,7 +84,14 @@ export const attachWorkerEvents = (worker: Worker, name: string, logger: typeof
 export const createWorkerShutdown = (worker: Worker, name: string, logger: typeof chatLogger = chatLogger) => {
   return () => {
     logger.info`Shutting down ${name} worker`
-    return Effect.runPromise(Effect.asVoid(Effect.tryPromise(() => worker.close())))
+    return Effect.runPromise(
+      Effect.asVoid(
+        Effect.tryPromise({
+          try: () => worker.close(),
+          catch: (cause) => new QueueWorkerError({ phase: 'close', cause }),
+        }),
+      ),
+    )
   }
 }
 
@@ -111,7 +124,10 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
             }),
           )
 
-          const result = yield* Effect.tryPromise(() => processor(job))
+          const result = yield* Effect.tryPromise({
+            try: () => processor(job),
+            catch: (cause) => new QueueWorkerError({ phase: 'process', cause }),
+          })
 
           yield* Effect.catch(queueJobService.markAttemptCompleted(trackedJob, result), (error) =>
             Effect.sync(() => {
@@ -163,7 +179,10 @@ export const registerShutdownSignals = ({
     shuttingDown = true
     void Effect.runFork(
       Effect.gen(function* () {
-        yield* Effect.tryPromise(() => Bun.sleep(timeoutMs))
+        yield* Effect.tryPromise({
+          try: () => Bun.sleep(timeoutMs),
+          catch: (cause) => new QueueWorkerError({ phase: 'shutdown-timeout', cause }),
+        })
         if (!forcedExitArmed) return
         logger.warn`Forced shutdown after ${timeoutMs}ms`
         process.exit(0)

package/src/effect/helpers.ts

@@ -1,123 +0,0 @@
-import { Cause, Effect } from 'effect'
-
-import { ServiceError } from './errors'
-
-export function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-  if (typeof value !== 'object' && typeof value !== 'function') {
-    return false
-  }
-
-  if (value === null) {
-    return false
-  }
-
-  return 'then' in value && typeof value.then === 'function'
-}
-
-type PromiseEffectEvaluator<A, E = never, R = never> =
-  | (() => PromiseLike<A> | Effect.Effect<A, E, R>)
-  | ((signal: AbortSignal) => PromiseLike<A> | Effect.Effect<A, E, R>)
-
-function invokePromiseEffectEvaluator<A, E, R>(
-  evaluate: PromiseEffectEvaluator<A, E, R>,
-): PromiseLike<A> | Effect.Effect<A, E, R> {
-  return (evaluate as () => PromiseLike<A> | Effect.Effect<A, E, R>)()
-}
-
-export function effectTryPromise<A, E = never, R = never>(
-  evaluate: PromiseEffectEvaluator<A, E, R>,
-): Effect.Effect<A, Cause.UnknownError, R>
-export function effectTryPromise<A, E1, E2, R>(
-  evaluate: PromiseEffectEvaluator<A, E1, R>,
-  onError: (cause: unknown) => E2,
-): Effect.Effect<A, E2, R>
-export function effectTryPromise<A, E1, E2, R>(
-  evaluate: PromiseEffectEvaluator<A, E1, R>,
-  onError?: (cause: unknown) => E2,
-): Effect.Effect<A, E2 | Cause.UnknownError, R> {
-  return Effect.suspend(() => {
-    try {
-      const value = invokePromiseEffectEvaluator(evaluate)
-      if (Effect.isEffect(value)) {
-        if (onError) {
-          return value.pipe(Effect.mapError((cause) => onError(cause)))
-        }
-
-        return value.pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
-      }
-
-      return onError
-        ? Effect.tryPromise({ try: () => value, catch: onError })
-        : Effect.tryPromise({ try: () => value, catch: (cause) => new Cause.UnknownError(cause) })
-    } catch (cause) {
-      return Effect.fail(onError ? onError(cause) : new Cause.UnknownError(cause))
-    }
-  })
-}
-
-export function effectTryServicePromise<A, E = never, R = never>(
-  evaluate: PromiseEffectEvaluator<A, E, R>,
-  message: string,
-): Effect.Effect<A, ServiceError, R> {
-  return Effect.suspend(() => {
-    try {
-      const value = invokePromiseEffectEvaluator(evaluate)
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new ServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({ try: () => value, catch: (cause) => new ServiceError({ message, cause }) })
-    } catch (cause) {
-      return Effect.fail(new ServiceError({ message, cause }))
-    }
-  })
-}
-
-export function makeEffectTryPromiseWithMessage<E>(onError: (message: string, cause: unknown) => E) {
-  return <A, E1 = never, R = never>(
-    evaluate: PromiseEffectEvaluator<A, E1, R>,
-    message: string,
-  ): Effect.Effect<A, E, R> => effectTryPromise(evaluate, (cause) => onError(message, cause))
-}
-
-export function makeEffectTryPromiseWithOperation<E>(
-  onError: (operation: string, message: string, cause: unknown) => E,
-) {
-  return <A, E1 = never, R = never>(
-    operation: string,
-    message: string,
-    evaluate: PromiseEffectEvaluator<A, E1, R>,
-  ): Effect.Effect<A, E, R> => effectTryPromise(evaluate, (cause) => onError(operation, message, cause))
-}
-
-export function effectTryMaybeAsync<A>(evaluate: () => A | PromiseLike<A>): Effect.Effect<A, Cause.UnknownError, never>
-export function effectTryMaybeAsync<A, E>(
-  evaluate: () => A | PromiseLike<A>,
-  onError: (cause: unknown) => E,
-): Effect.Effect<A, E, never>
-export function effectTryMaybeAsync<A, E>(
-  evaluate: () => A | PromiseLike<A>,
-  onError?: (cause: unknown) => E,
-): Effect.Effect<A, E | Cause.UnknownError, never> {
-  return Effect.suspend(() => {
-    try {
-      const value = evaluate()
-      return isPromiseLike(value)
-        ? onError
-          ? effectTryPromise(() => value, onError)
-          : effectTryPromise(() => value)
-        : Effect.succeed(value)
-    } catch (cause) {
-      return Effect.fail(onError ? onError(cause) : new Cause.UnknownError(cause))
-    }
-  })
-}
-
-export function iterateEffect<A, E, R>(
-  initial: A,
-  options: { while: (state: A) => boolean; body: (state: A) => Effect.Effect<A, E, R> },
-): Effect.Effect<A, E, R> {
-  const step = (state: A): Effect.Effect<A, E, R> =>
-    options.while(state) ? options.body(state).pipe(Effect.flatMap(step)) : Effect.succeed(state)
-  return Effect.suspend(() => step(initial))
-}