@lota-sdk/core 0.4.12 → 0.4.14

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

@@ -2,12 +2,7 @@ import type { OwnershipDispatchContext, PlanNodeSpec, PluginPlanNodeOwner } from
 import { Context, Effect, Layer } from 'effect'
 
 import { BadRequestError, ServiceError } from '../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RuntimeConfigServiceTag } from '../effect/services'
-
-const tryPluginExecutorPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ServiceError({ message, cause }),
-)
 import type { LotaPlugin, PluginNodeExecutionParams } from '../runtime/plugin-types'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { PlanValidationIssueInput } from './plan/plan-validator.service'
@@ -107,8 +102,8 @@ export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
         })
       }
 
-      return yield* tryPluginExecutorPromise(
-        () =>
+      return yield* Effect.tryPromise({
+        try: () =>
           nodeExecutor.executeNode(
             buildPluginExecutionParams({
               owner,
@@ -117,8 +112,9 @@ export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
               context: params.context,
             }),
           ),
-        `Plugin executor "${owner.ref}.${owner.operation}" failed.`,
-      ).pipe(Effect.withSpan('PluginExecutor.invoke'))
+        catch: (cause) =>
+          new ServiceError({ message: `Plugin executor "${owner.ref}.${owner.operation}" failed.`, cause }),
+      }).pipe(Effect.withSpan('PluginExecutor.invoke'))
     }),
   }
 }

package/src/services/queue-job.service.ts

@@ -14,7 +14,6 @@ import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { isRetriableTransactionConflict } from '../db/transaction-conflict'
 import { BadRequestError, DatabaseError } from '../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { DatabaseServiceTag } from '../effect/services'
 import { createDeterministicRecordId } from '../utils/crypto'
 import { nowDate, unsafeDateFrom } from '../utils/date-time'
@@ -185,17 +184,6 @@ function getQueuedStatus(job: TrackedBullJobLike): QueueJobStatus {
   return typeof delay === 'number' && delay > 0 ? 'delayed' : 'waiting'
 }
 
-const effectTryQueueJobPersistence = makeEffectTryPromiseWithMessage(
-  (message, cause) => new DatabaseError({ message, cause }),
-)
-
-function tryQueueJobPersistence<A>(
-  message: string,
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, DatabaseError> {
-  return effectTryQueueJobPersistence(evaluate, message)
-}
-
 function withPersistenceRetry<T>(work: Effect.Effect<T, DatabaseError>): Effect.Effect<T, DatabaseError> {
   return Effect.retry(work, {
     times: PERSISTENCE_MAX_ATTEMPTS - 1,
@@ -219,7 +207,14 @@ export function makeQueueJobService(db: SurrealDBService) {
 
     recordEnqueued(job: TrackedBullJobLike, context?: Record<string, unknown>) {
       return Effect.gen(function* () {
-        yield* tryQueueJobPersistence('Failed to connect before recording queued job metadata', () => db.connect())
+        yield* db
+          .connect()
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new DatabaseError({ message: 'Failed to connect before recording queued job metadata', cause }),
+            ),
+          )
 
         const bullmqJobId = yield* getBullmqJobId(job)
         const queueJobId = yield* getQueueJobRecordId(job)
@@ -228,8 +223,8 @@ export function makeQueueJobService(db: SurrealDBService) {
 
         return yield* withPersistenceRetry(
           Effect.gen(function* () {
-            yield* tryQueueJobPersistence('Failed to upsert queued job metadata', () =>
-              db.upsert(
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB,
                 queueJobId,
                 compactRecord({
@@ -245,8 +240,12 @@ export function makeQueueJobService(db: SurrealDBService) {
                   queuedAt,
                 }),
                 QueueJobRowSchema,
-              ),
-            )
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) => new DatabaseError({ message: 'Failed to upsert queued job metadata', cause }),
+                ),
+              )
 
             return recordIdToString(queueJobId, TABLES.QUEUE_JOB)
           }),
@@ -256,7 +255,14 @@ export function makeQueueJobService(db: SurrealDBService) {
 
     markAttemptStarted(job: TrackedBullJobLike) {
       return Effect.gen(function* () {
-        yield* tryQueueJobPersistence('Failed to connect before marking queue job attempt started', () => db.connect())
+        yield* db
+          .connect()
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new DatabaseError({ message: 'Failed to connect before marking queue job attempt started', cause }),
+            ),
+          )
 
         const attemptNumber = resolveAttemptNumber(job)
         const bullmqJobId = yield* getBullmqJobId(job).pipe(
@@ -273,8 +279,8 @@ export function makeQueueJobService(db: SurrealDBService) {
 
         return yield* withPersistenceRetry(
           Effect.gen(function* () {
-            yield* tryQueueJobPersistence('Failed to upsert queue job start metadata', () =>
-              db.upsert(
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB,
                 queueJobId,
                 compactRecord({
@@ -292,17 +298,25 @@ export function makeQueueJobService(db: SurrealDBService) {
                   startedAt,
                 }),
                 QueueJobRowSchema,
-              ),
-            )
-
-            yield* tryQueueJobPersistence('Failed to upsert queue job attempt start metadata', () =>
-              db.upsert(
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) => new DatabaseError({ message: 'Failed to upsert queue job start metadata', cause }),
+                ),
+              )
+
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB_ATTEMPT,
                 attemptId,
                 { queueJobId, attemptNumber, status: 'active', startedAt },
                 QueueJobAttemptRowSchema,
-              ),
-            )
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) => new DatabaseError({ message: 'Failed to upsert queue job attempt start metadata', cause }),
+                ),
+              )
 
             return recordIdToString(queueJobId, TABLES.QUEUE_JOB)
           }),
@@ -312,9 +326,14 @@ export function makeQueueJobService(db: SurrealDBService) {
 
     markAttemptCompleted(job: TrackedBullJobLike, result: unknown) {
       return Effect.gen(function* () {
-        yield* tryQueueJobPersistence('Failed to connect before marking queue job attempt completed', () =>
-          db.connect(),
-        )
+        yield* db
+          .connect()
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new DatabaseError({ message: 'Failed to connect before marking queue job attempt completed', cause }),
+            ),
+          )
 
         const attemptNumber = resolveAttemptNumber(job)
         const bullmqJobId = yield* getBullmqJobId(job)
@@ -325,13 +344,20 @@ export function makeQueueJobService(db: SurrealDBService) {
 
         yield* withPersistenceRetry(
           Effect.gen(function* () {
-            const existingAttempt = yield* tryQueueJobPersistence(
-              'Failed to load existing queue job attempt before completion update',
-              () => db.findOne(TABLES.QUEUE_JOB_ATTEMPT, { id: attemptId }, QueueJobAttemptRowSchema),
-            )
-
-            yield* tryQueueJobPersistence('Failed to upsert completed queue job attempt metadata', () =>
-              db.upsert(
+            const existingAttempt = yield* db
+              .findOne(TABLES.QUEUE_JOB_ATTEMPT, { id: attemptId }, QueueJobAttemptRowSchema)
+              .pipe(
+                Effect.mapError(
+                  (cause) =>
+                    new DatabaseError({
+                      message: 'Failed to load existing queue job attempt before completion update',
+                      cause,
+                    }),
+                ),
+              )
+
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB_ATTEMPT,
                 attemptId,
                 compactRecord({
@@ -346,11 +372,16 @@ export function makeQueueJobService(db: SurrealDBService) {
                     : 0,
                 }),
                 QueueJobAttemptRowSchema,
-              ),
-            )
-
-            yield* tryQueueJobPersistence('Failed to upsert completed queue job metadata', () =>
-              db.upsert(
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) =>
+                    new DatabaseError({ message: 'Failed to upsert completed queue job attempt metadata', cause }),
+                ),
+              )
+
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB,
                 queueJobId,
                 compactRecord({
@@ -370,8 +401,12 @@ export function makeQueueJobService(db: SurrealDBService) {
                   lastError: undefined,
                 }),
                 QueueJobRowSchema,
-              ),
-            )
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) => new DatabaseError({ message: 'Failed to upsert completed queue job metadata', cause }),
+                ),
+              )
           }),
         )
       })
@@ -379,7 +414,14 @@ export function makeQueueJobService(db: SurrealDBService) {
 
     markAttemptFailed(job: TrackedBullJobLike, error: unknown) {
       return Effect.gen(function* () {
-        yield* tryQueueJobPersistence('Failed to connect before marking queue job attempt failed', () => db.connect())
+        yield* db
+          .connect()
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new DatabaseError({ message: 'Failed to connect before marking queue job attempt failed', cause }),
+            ),
+          )
 
         const attemptNumber = resolveAttemptNumber(job)
         const bullmqJobId = yield* getBullmqJobId(job)
@@ -393,13 +435,20 @@ export function makeQueueJobService(db: SurrealDBService) {
 
         yield* withPersistenceRetry(
           Effect.gen(function* () {
-            const existingAttempt = yield* tryQueueJobPersistence(
-              'Failed to load existing queue job attempt before failure update',
-              () => db.findOne(TABLES.QUEUE_JOB_ATTEMPT, { id: attemptId }, QueueJobAttemptRowSchema),
-            )
-
-            yield* tryQueueJobPersistence('Failed to upsert failed queue job attempt metadata', () =>
-              db.upsert(
+            const existingAttempt = yield* db
+              .findOne(TABLES.QUEUE_JOB_ATTEMPT, { id: attemptId }, QueueJobAttemptRowSchema)
+              .pipe(
+                Effect.mapError(
+                  (cause) =>
+                    new DatabaseError({
+                      message: 'Failed to load existing queue job attempt before failure update',
+                      cause,
+                    }),
+                ),
+              )
+
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB_ATTEMPT,
                 attemptId,
                 compactRecord({
@@ -414,11 +463,16 @@ export function makeQueueJobService(db: SurrealDBService) {
                     : 0,
                 }),
                 QueueJobAttemptRowSchema,
-              ),
-            )
-
-            yield* tryQueueJobPersistence('Failed to upsert failed queue job metadata', () =>
-              db.upsert(
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) =>
+                    new DatabaseError({ message: 'Failed to upsert failed queue job attempt metadata', cause }),
+                ),
+              )
+
+            yield* db
+              .upsert(
                 TABLES.QUEUE_JOB,
                 queueJobId,
                 compactRecord({
@@ -437,8 +491,12 @@ export function makeQueueJobService(db: SurrealDBService) {
                   lastError: normalizedError,
                 }),
                 QueueJobRowSchema,
-              ),
-            )
+              )
+              .pipe(
+                Effect.mapError(
+                  (cause) => new DatabaseError({ message: 'Failed to upsert failed queue job metadata', cause }),
+                ),
+              )
           }),
         )
       })

package/src/services/recent-activity-title.service.ts

@@ -1,14 +1,15 @@
 import { Context, Effect, Layer } from 'effect'
 
+import { AiGatewayModelsTag } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { ServiceError } from '../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { AgentConfigServiceTag } from '../effect/services'
 import type { HelperModelRuntime } from '../runtime/helper-model'
 import { HelperModelTag } from '../runtime/helper-model'
 import { normalizeTitle } from '../runtime/title-helpers'
 import {
-  createRecentActivityTitleRefinerAgent,
+  makeRecentActivityTitleRefinerAgentFactory,
   RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
 } from '../system-agents/recent-activity-title-refiner.agent'
 import type { makeRecentActivityService } from './recent-activity.service'
@@ -16,10 +17,6 @@ import { RecentActivityServiceTag } from './recent-activity.service'
 
 const RECENT_ACTIVITY_TITLE_TIMEOUT_MS = 60_000
 
-const tryRecentActivityTitlePromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ServiceError({ message, cause }),
-)
-
 function buildRefinementPromptInput(
   candidate: {
     id: string
@@ -48,9 +45,11 @@ function buildRefinementPromptInput(
 
 export function makeRecentActivityTitleService(
   agentConfig: ResolvedAgentConfig,
+  aiGatewayModels: AiGatewayModels,
   recentActivityService: ReturnType<typeof makeRecentActivityService>,
   helperModelRuntime: HelperModelRuntime,
 ) {
+  const refinerAgentFactory = makeRecentActivityTitleRefinerAgentFactory(aiGatewayModels, agentConfig)
   const refineRecentActivityTitle = (activityId: string) =>
     Effect.gen(function* () {
       const candidate = yield* recentActivityService.getRefinementCandidate(activityId)
@@ -64,17 +63,18 @@ export function makeRecentActivityTitleService(
       }
 
       const refinedTitle = normalizeTitle(
-        yield* tryRecentActivityTitlePromise(
-          () =>
+        yield* Effect.tryPromise({
+          try: () =>
             helperModelRuntime.generateHelperText({
               tag: 'recent-activity-title-refinement',
-              createAgent: (options) => createRecentActivityTitleRefinerAgent(agentConfig, options),
+              createAgent: refinerAgentFactory,
               defaultSystemPrompt: RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
               timeoutMs: RECENT_ACTIVITY_TITLE_TIMEOUT_MS,
               messages: [{ role: 'user', content: promptInput }],
             }),
-          'Failed to generate recent activity title refinement.',
-        ),
+          catch: (cause) =>
+            new ServiceError({ message: 'Failed to generate recent activity title refinement.', cause }),
+        }),
       )
       if (
         !recentActivityService.isAgentTitleUseful({
@@ -101,8 +101,9 @@ export const RecentActivityTitleServiceLive = Layer.effect(
   RecentActivityTitleServiceTag,
   Effect.gen(function* () {
     const agentConfig = yield* AgentConfigServiceTag
+    const aiGatewayModels = yield* AiGatewayModelsTag
     const recentActivityService = yield* RecentActivityServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    return makeRecentActivityTitleService(agentConfig, recentActivityService, helperModelRuntime)
+    return makeRecentActivityTitleService(agentConfig, aiGatewayModels, recentActivityService, helperModelRuntime)
   }),
 )

package/src/services/recent-activity.service.ts

@@ -22,6 +22,7 @@ import type { RecordIdInput, RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { DatabaseServiceTag } from '../effect/services'
+import { toValidationError } from '../effect/zod'
 import { createDeterministicRecordId } from '../utils/crypto'
 import { nowDate, toIsoDateTimeString, toOptionalIsoDateTimeString, unsafeDateFrom } from '../utils/date-time'
 import { compactRecord, compactWhitespace, truncateText } from '../utils/string'
@@ -156,7 +157,11 @@ export function makeRecentActivityService(db: SurrealDBService) {
     event: RecentActivityEventInput
   }) {
     return Effect.gen(function* () {
-      const parsedEvent = sanitizeEvent(RecentActivityEventInputSchema.parse(params.event))
+      const parsedInput = yield* Effect.try({
+        try: () => RecentActivityEventInputSchema.parse(params.event),
+        catch: (cause) => toValidationError(cause, 'Failed to validate recent activity event.'),
+      })
+      const parsedEvent = sanitizeEvent(parsedInput)
       const orgIdString = recordIdToString(params.orgId, TABLES.ORGANIZATION)
       const userIdString = recordIdToString(params.userId, TABLES.USER)
       const eventRecordId = createDeterministicRecordId(

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

@@ -2,21 +2,16 @@ import { normalizeMessageBatch } from '@lota-sdk/shared'
 import { Context, Effect, Layer, Schema } from 'effect'
 import { z } from 'zod'
 
-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',
+  '@lota-sdk/core/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'])
@@ -157,20 +152,26 @@ export function makeSocialChatHistoryService(
         multi.zadd(workspaceIndexKey(message.workspaceId), score, storageKey)
       }
 
-      yield* tryRedisPromise(() => multi.exec(), 'Failed to upsert social chat messages.')
+      yield* Effect.tryPromise({
+        try: () => multi.exec(),
+        catch: (cause) => new SocialChatHistoryError({ message: 'Failed to upsert social chat messages.', cause }),
+      })
       return normalizedMessages
     })
 
   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.',
-      )
+      const storageKeys = yield* Effect.tryPromise({
+        try: () => conn.zrange(threadIndexKey(params.workspaceId, params.threadId), 0, -1),
+        catch: (cause) => new SocialChatHistoryError({ message: 'Failed to list thread message keys.', cause }),
+      })
       if (storageKeys.length === 0) return [] as SocialChatHistoryMessage[]
 
-      const storedValues = yield* tryRedisPromise(() => conn.mget(storageKeys), 'Failed to read thread messages.')
+      const storedValues = yield* Effect.tryPromise({
+        try: () => conn.mget(storageKeys),
+        catch: (cause) => new SocialChatHistoryError({ message: 'Failed to read thread messages.', cause }),
+      })
       const parsedMessages = yield* Effect.forEach(storedValues, parseStoredMessageEffect)
       return parsedMessages
         .filter((message): message is SocialChatHistoryMessage => message !== null)
@@ -188,16 +189,19 @@ export function makeSocialChatHistoryService(
       const scoreStart =
         params.cursor?.createdAt.getTime() ??
         (params.onboardingCutoff ? params.onboardingCutoff.getTime() : Number.NEGATIVE_INFINITY)
-      const storageKeys = yield* tryRedisPromise(
-        () =>
+      const storageKeys = yield* Effect.tryPromise({
+        try: () =>
           params.cursor || params.onboardingCutoff
             ? conn.zrangebyscore(indexKey, scoreStart, '+inf')
             : conn.zrange(indexKey, 0, -1),
-        'Failed to list workspace message keys.',
-      )
+        catch: (cause) => new SocialChatHistoryError({ message: 'Failed to list workspace message keys.', cause }),
+      })
       if (storageKeys.length === 0) return [] as SocialChatHistoryMessage[]
 
-      const storedValues = yield* tryRedisPromise(() => conn.mget(storageKeys), 'Failed to read workspace messages.')
+      const storedValues = yield* Effect.tryPromise({
+        try: () => conn.mget(storageKeys),
+        catch: (cause) => new SocialChatHistoryError({ message: 'Failed to read workspace messages.', cause }),
+      })
       const parsedMessages = yield* Effect.forEach(storedValues, parseStoredMessageEffect)
       return parsedMessages
         .filter((message): message is SocialChatHistoryMessage => message !== null)
@@ -225,20 +229,20 @@ export function makeSocialChatHistoryService(
     }).pipe(Effect.map((messages) => messages.length > 0))
 
   const getBackgroundCursorEffect = (kind: LotaRuntimeBackgroundCursorKind, workspaceId: string) =>
-    tryRedisPromise(
-      () => redis.getConnection().get(cursorKey(kind, workspaceId)),
-      'Failed to read background cursor.',
-    ).pipe(Effect.flatMap((value) => parseCursorEffect(value)))
+    Effect.tryPromise({
+      try: () => redis.getConnection().get(cursorKey(kind, workspaceId)),
+      catch: (cause) => new SocialChatHistoryError({ message: 'Failed to read background cursor.', cause }),
+    }).pipe(Effect.flatMap((value) => parseCursorEffect(value)))
 
   const setBackgroundCursorEffect = (
     kind: LotaRuntimeBackgroundCursorKind,
     workspaceId: string,
     cursor: LotaRuntimeBackgroundCursor,
   ) =>
-    tryRedisPromise(
-      () => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor)),
-      'Failed to write background cursor.',
-    ).pipe(Effect.asVoid)
+    Effect.tryPromise({
+      try: () => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor)),
+      catch: (cause) => new SocialChatHistoryError({ message: 'Failed to write background cursor.', cause }),
+    }).pipe(Effect.asVoid)
 
   return {
     upsertMessages: upsertMessagesEffect,

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

@@ -2,12 +2,7 @@ import type { OwnershipDispatchContext, PlanNodeResult, PlanNodeSpec, SystemPlan
 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 type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { PlanValidationIssueInput } from './plan/plan-validator.service'
@@ -110,8 +105,8 @@ export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
         })
       }
 
-      return yield* trySystemExecutorPromise(
-        () =>
+      return yield* Effect.tryPromise({
+        try: () =>
           executor.executeNode(
             buildSystemExecutionParams({
               owner,
@@ -120,8 +115,9 @@ export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
               context: params.context,
             }),
           ),
-        `System executor "${owner.ref}.${owner.operation}" failed.`,
-      ).pipe(Effect.withSpan('SystemExecutor.invoke'))
+        catch: (cause) =>
+          new ServiceError({ message: `System executor "${owner.ref}.${owner.operation}" failed.`, cause }),
+      }).pipe(Effect.withSpan('SystemExecutor.invoke'))
     }),
   }
 }

package/src/services/thread/thread-active-run.ts

@@ -6,7 +6,7 @@ import type { RecordIdRef } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { ActiveThreadRunConflictError, DatabaseError, RedisError } from '../../effect/errors'
+import { ERROR_TAGS, ActiveThreadRunConflictError, DatabaseError, RedisError } from '../../effect/errors'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { withLeaseLock } from '../../redis/redis-lease-lock'
 import type { ThreadRecordStore } from './thread-record-store'
@@ -176,7 +176,7 @@ export function createThreadActiveRunHelpers(deps: {
       },
       fn,
     ).pipe(
-      Effect.catchTag('LockAcquisitionError', () =>
+      Effect.catchTag(ERROR_TAGS.LockAcquisitionError, () =>
         Effect.gen(function* () {
           const activeRunId = (yield* Effect.catch(getActiveRunIdEffect(threadId), () => Effect.succeed(null))) ?? ''
           return yield* new ActiveThreadRunConflictError({