@lota-sdk/core 0.4.9 → 0.4.10

package/src/services/plan/plan-run.service.ts

@@ -33,7 +33,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../../utils/date-time'
 
@@ -159,7 +159,10 @@ function serializeEvent(event: PlanEventRecord): SerializablePlanEvent {
   }
 }
 
-type PlanRunServiceError = ServiceError
+class PlanRunServiceError extends Schema.TaggedErrorClass<PlanRunServiceError>()('PlanRunServiceError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
 
 class PlanRunNotFoundError extends Schema.TaggedErrorClass<PlanRunNotFoundError>()('PlanRunNotFoundError', {
   message: Schema.String,
@@ -172,25 +175,15 @@ class PlanRunSerializationError extends Schema.TaggedErrorClass<PlanRunSerializa
   { message: Schema.String },
 ) {}
 
+const effectTryPlanRunPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new PlanRunServiceError({ message, cause }),
+)
+
 function tryPlanRunPromise<A>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, PlanRunServiceError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new ServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new ServiceError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new ServiceError({ message, cause }))
-    }
-  })
+  return effectTryPlanRunPromise(evaluate, message)
 }
 
 export function makePlanRunService(db: SurrealDBService) {
@@ -632,7 +625,7 @@ export function makePlanRunService(db: SurrealDBService) {
 }
 
 export class PlanRunServiceTag extends Context.Service<PlanRunServiceTag, ReturnType<typeof makePlanRunService>>()(
-  'PlanRunService',
+  '@lota-sdk/core/PlanRunService',
 ) {}
 
 export const PlanRunServiceLive = Layer.effect(

package/src/services/plan/plan-scheduler.service.ts

@@ -8,7 +8,7 @@ import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { NotFoundError } from '../../effect/errors'
-import { effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
 import { nowDate, nowEpochMillis, toDatabaseDateTime, unsafeDateFrom } from '../../utils/date-time'
 
@@ -23,12 +23,7 @@ class PlanSchedulerError extends Schema.TaggedErrorClass<PlanSchedulerError>()('
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-function effectTryPromise<A>(
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-  message: string,
-): Effect.Effect<A, PlanSchedulerError> {
-  return effectTryPromiseShared(evaluate, (cause) => new PlanSchedulerError({ message, cause }))
-}
+const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new PlanSchedulerError({ message, cause }))
 
 function failPlanScheduler(message: string, cause?: unknown): Effect.Effect<never, PlanSchedulerError> {
   return Effect.fail(new PlanSchedulerError({ message, ...(cause === undefined ? {} : { cause }) }))
@@ -143,13 +138,9 @@ export function makePlanSchedulerService(db: SurrealDBService) {
       const isRecurring = schedule.scheduleSpec.type === 'cron' || schedule.scheduleSpec.type === 'monitoring'
       const maxReached = schedule.scheduleSpec.maxFires !== undefined && newFireCount >= schedule.scheduleSpec.maxFires
 
-      let nextFireAt: Date | null = null
-      let newStatus: 'active' | 'completed' = 'completed'
-
-      if (isRecurring && !maxReached) {
-        nextFireAt = yield* computeNextFireAtEffect(schedule.scheduleSpec, now)
-        newStatus = 'active'
-      }
+      const isActive = isRecurring && !maxReached
+      const nextFireAt: Date | null = isActive ? yield* computeNextFireAtEffect(schedule.scheduleSpec, now) : null
+      const newStatus: 'active' | 'completed' = isActive ? 'active' : 'completed'
 
       yield* effectTryPromise(
         () =>
@@ -167,7 +158,6 @@ export function makePlanSchedulerService(db: SurrealDBService) {
         'Failed to update fired schedule.',
       )
 
-      let shouldRecoverDeadlineChecks = false
       if (newStatus === 'active') {
         if (!nextFireAt) {
           return yield* new PlanSchedulerError({ message: 'Recurring schedules must resolve a next fire time.' })
@@ -185,6 +175,7 @@ export function makePlanSchedulerService(db: SurrealDBService) {
 
       const runId = schedule.runId
       const nodeId = schedule.nodeId
+      const promotedNode = Boolean(runId && nodeId)
       if (runId && nodeId) {
         yield* effectTryPromise(
           () =>
@@ -195,26 +186,29 @@ export function makePlanSchedulerService(db: SurrealDBService) {
             }),
           'Failed to promote delayed plan node.',
         )
-        shouldRecoverDeadlineChecks = true
       }
 
-      if (schedule.planSpecId && !schedule.runId) {
-        const cycle = yield* effectTryPromise(
-          () =>
-            db.findOne(
-              TABLES.PLAN_CYCLE,
-              { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
-              PlanCycleRecordSchema,
-            ),
-          'Failed to load plan cycle for schedule.',
-        )
-        if (cycle) {
-          yield* effectTryPromise(() => runtimeDeps.advanceCycle(cycle.id), 'Failed to advance plan cycle.')
-          shouldRecoverDeadlineChecks = true
-        }
-      }
+      const advancedCycle =
+        schedule.planSpecId && !schedule.runId
+          ? yield* effectTryPromise(
+              () =>
+                db.findOne(
+                  TABLES.PLAN_CYCLE,
+                  { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
+                  PlanCycleRecordSchema,
+                ),
+              'Failed to load plan cycle for schedule.',
+            ).pipe(
+              Effect.tap((cycle) =>
+                cycle
+                  ? effectTryPromise(() => runtimeDeps.advanceCycle(cycle.id), 'Failed to advance plan cycle.')
+                  : Effect.void,
+              ),
+              Effect.map((cycle) => cycle !== null),
+            )
+          : false
 
-      if (shouldRecoverDeadlineChecks) {
+      if (promotedNode || advancedCycle) {
         yield* effectTryPromise(() => runtimeDeps.recoverDeadlineChecks(), 'Failed to recover deadline checks.')
       }
     })
@@ -374,7 +368,7 @@ export function makePlanSchedulerService(db: SurrealDBService) {
 export class PlanSchedulerServiceTag extends Context.Service<
   PlanSchedulerServiceTag,
   ReturnType<typeof makePlanSchedulerService>
->()('PlanSchedulerService') {}
+>()('@lota-sdk/core/PlanSchedulerService') {}
 
 export const PlanSchedulerServiceLive = Layer.effect(
   PlanSchedulerServiceTag,

package/src/services/plan/plan-template.service.ts

@@ -212,7 +212,7 @@ export function makePlanTemplateService(deps: PlanTemplateDeps) {
 export class PlanTemplateServiceTag extends Context.Service<
   PlanTemplateServiceTag,
   ReturnType<typeof makePlanTemplateService>
->()('PlanTemplateService') {}
+>()('@lota-sdk/core/PlanTemplateService') {}
 
 export const PlanTemplateServiceLive = Layer.effect(
   PlanTemplateServiceTag,

package/src/services/plan/plan-transaction-events.ts

@@ -23,11 +23,14 @@ export function withTransactionAndEventsEffect<T, E, R>(params: {
           (error) => new PlanTransactionEventsError({ message: 'Failed to run plan transaction.', cause: error }),
         ),
       )
-    yield* Effect.tryPromise({
-      try: () => params.planEventDeliveryService.dispatchEvents(emittedEvents),
-      catch: (error) =>
-        new PlanTransactionEventsError({ message: 'Failed to dispatch plan transaction events.', cause: error }),
-    })
+    yield* params.planEventDeliveryService
+      .dispatchEventsEffect(emittedEvents)
+      .pipe(
+        Effect.mapError(
+          (error) =>
+            new PlanTransactionEventsError({ message: 'Failed to dispatch plan transaction events.', cause: error }),
+        ),
+      )
     return result
   })
 }

package/src/services/plan/plan-validator.service.ts

@@ -897,7 +897,7 @@ export function makePlanValidatorService(planCoordinationService: ReturnType<typ
 export class PlanValidatorServiceTag extends Context.Service<
   PlanValidatorServiceTag,
   ReturnType<typeof makePlanValidatorService>
->()('PlanValidatorService') {}
+>()('@lota-sdk/core/PlanValidatorService') {}
 
 export const PlanValidatorServiceLive = Layer.effect(
   PlanValidatorServiceTag,

package/src/services/plan/plan-workspace.service.ts

@@ -1,10 +1,14 @@
 import { Context, Effect, Layer, Schema } from 'effect'
 
+import { ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { RedisServiceTag } from '../../effect/services'
 import { toValidationError } from '../../effect/zod'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { nowEpochMillis } from '../../utils/date-time'
 
+const tryWorkspacePromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
 const PlanWorkspaceEntrySchema = Schema.Struct({
   value: Schema.Unknown,
   version: Schema.Number,
@@ -29,10 +33,9 @@ function parsePlanWorkspaceEntryEffect(
   fieldKey: string,
   raw: string,
 ): Effect.Effect<PlanWorkspaceEntry, ReturnType<typeof toValidationError>> {
-  return Effect.try({
-    try: () => Schema.decodeUnknownSync(PlanWorkspaceEntryJsonSchema)(raw),
-    catch: (error) => toValidationError(error, `Invalid plan workspace entry JSON for "${fieldKey}"`),
-  })
+  return Schema.decodeUnknownEffect(PlanWorkspaceEntryJsonSchema)(raw).pipe(
+    Effect.mapError((error) => toValidationError(error, `Invalid plan workspace entry JSON for "${fieldKey}"`)),
+  )
 }
 
 export function makePlanWorkspaceService(redis: RedisConnectionManager) {
@@ -56,7 +59,10 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
         timestamp: nowEpochMillis(),
       }
       const serialized = yield* Schema.encodeEffect(PlanWorkspaceEntryJsonSchema)(entry)
-      yield* Effect.tryPromise(() => conn.hset(hashKey, fieldKey, serialized))
+      yield* tryWorkspacePromise(
+        () => conn.hset(hashKey, fieldKey, serialized),
+        'Failed to write plan workspace entry.',
+      )
     })
 
   const snapshotReadEffect = (params: { runId: string; readerNodeId: string; snapshotSequence?: number }) =>
@@ -64,7 +70,7 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
       const conn = redis.getConnection()
       const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
       const nodePrefix = `${params.readerNodeId}:`
-      const all = yield* Effect.tryPromise(() => conn.hgetall(hashKey))
+      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace snapshot.')
       const result: Record<string, PlanWorkspaceEntry> = {}
       for (const [fieldKey, raw] of Object.entries(all)) {
         if (!fieldKey.startsWith(nodePrefix)) continue
@@ -83,11 +89,11 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
       const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
       const key = params.key
       if (key !== undefined) {
-        const raw = yield* Effect.tryPromise(() => conn.hget(hashKey, key))
+        const raw = yield* tryWorkspacePromise(() => conn.hget(hashKey, key), 'Failed to read plan workspace entry.')
         if (!raw) return {}
         return { [key]: yield* parsePlanWorkspaceEntryEffect(key, raw) }
       }
-      const all = yield* Effect.tryPromise(() => conn.hgetall(hashKey))
+      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace entries.')
       const result: Record<string, PlanWorkspaceEntry> = {}
       for (const [k, v] of Object.entries(all)) {
         result[k] = yield* parsePlanWorkspaceEntryEffect(k, v)
@@ -97,10 +103,10 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
 
   const cleanupEffect = (runId: string) =>
     Effect.asVoid(
-      Effect.tryPromise(() => {
+      tryWorkspacePromise(() => {
         const conn = redis.getConnection()
         return conn.del(`${PLAN_WORKSPACE_KEY_PREFIX}${runId}`)
-      }),
+      }, 'Failed to clean up plan workspace.'),
     )
 
   return {
@@ -114,7 +120,7 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
 export class PlanWorkspaceServiceTag extends Context.Service<
   PlanWorkspaceServiceTag,
   ReturnType<typeof makePlanWorkspaceService>
->()('PlanWorkspaceService') {}
+>()('@lota-sdk/core/PlanWorkspaceService') {}
 
 export const PlanWorkspaceServiceLive = Layer.effect(
   PlanWorkspaceServiceTag,

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

@@ -1,8 +1,13 @@
 import type { OwnershipDispatchContext, PlanNodeSpec, PluginPlanNodeOwner } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
-import { BadRequestError } from '../effect/errors'
+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'
@@ -82,28 +87,28 @@ export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
       return []
     },
 
-    executeNode(params: {
+    executeNode: Effect.fn('PluginExecutor.executeNode')(function* (params: {
       nodeSpec: PlanNodeSpec
       resolvedInput: Record<string, unknown>
       context: OwnershipDispatchContext
     }) {
-      return Effect.gen(function* () {
-        const owner = params.nodeSpec.owner
-        if (!isPluginOwner(owner)) {
-          return yield* new BadRequestError({
-            message: `PluginExecutor cannot execute owner type "${owner.executorType}".`,
-          })
-        }
+      const owner = params.nodeSpec.owner
+      if (!isPluginOwner(owner)) {
+        return yield* new BadRequestError({
+          message: `PluginExecutor cannot execute owner type "${owner.executorType}".`,
+        })
+      }
 
-        const plugin = getPluginRuntime()[owner.ref]
-        const nodeExecutor = plugin?.nodeExecutor
-        if (!plugin || !nodeExecutor || !nodeExecutor.supportedOperations.includes(owner.operation)) {
-          return yield* new BadRequestError({
-            message: `Plugin executor ${owner.ref}.${owner.operation} is not registered.`,
-          })
-        }
+      const plugin = getPluginRuntime()[owner.ref]
+      const nodeExecutor = plugin?.nodeExecutor
+      if (!plugin || !nodeExecutor || !nodeExecutor.supportedOperations.includes(owner.operation)) {
+        return yield* new BadRequestError({
+          message: `Plugin executor ${owner.ref}.${owner.operation} is not registered.`,
+        })
+      }
 
-        return yield* Effect.tryPromise(() =>
+      return yield* tryPluginExecutorPromise(
+        () =>
           nodeExecutor.executeNode(
             buildPluginExecutionParams({
               owner,
@@ -112,16 +117,16 @@ export function makePluginExecutorService(config: ResolvedLotaRuntimeConfig) {
               context: params.context,
             }),
           ),
-        )
-      })
-    },
+        `Plugin executor "${owner.ref}.${owner.operation}" failed.`,
+      ).pipe(Effect.withSpan('PluginExecutor.invoke'))
+    }),
   }
 }
 
 export class PluginExecutorServiceTag extends Context.Service<
   PluginExecutorServiceTag,
   ReturnType<typeof makePluginExecutorService>
->()('PluginExecutorService') {}
+>()('@lota-sdk/core/PluginExecutorService') {}
 
 export const PluginExecutorServiceLive = Layer.effect(
   PluginExecutorServiceTag,

package/src/services/quality-metrics.service.ts

@@ -139,7 +139,7 @@ export function makeQualityMetricsService(db: SurrealDBService) {
 export class QualityMetricsServiceTag extends Context.Service<
   QualityMetricsServiceTag,
   ReturnType<typeof makeQualityMetricsService>
->()('QualityMetricsService') {}
+>()('@lota-sdk/core/QualityMetricsService') {}
 
 export const QualityMetricsServiceLive = Layer.effect(
   QualityMetricsServiceTag,

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

@@ -14,6 +14,7 @@ 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'
@@ -184,25 +185,15 @@ 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,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
 ): Effect.Effect<A, DatabaseError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new DatabaseError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause: unknown) => new DatabaseError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new DatabaseError({ message, cause }))
-    }
-  })
+  return effectTryQueueJobPersistence(evaluate, message)
 }
 
 function withPersistenceRetry<T>(work: Effect.Effect<T, DatabaseError>): Effect.Effect<T, DatabaseError> {
@@ -456,7 +447,7 @@ export function makeQueueJobService(db: SurrealDBService) {
 }
 
 export class QueueJobServiceTag extends Context.Service<QueueJobServiceTag, ReturnType<typeof makeQueueJobService>>()(
-  'QueueJobService',
+  '@lota-sdk/core/QueueJobService',
 ) {}
 
 export const QueueJobServiceLive = Layer.effect(

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

@@ -1,5 +1,7 @@
 import { Context, Effect, Layer } from 'effect'
 
+import { ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import type { HelperModelRuntime } from '../runtime/helper-model'
 import { HelperModelTag } from '../runtime/helper-model'
 import { normalizeTitle } from '../runtime/title-helpers'
@@ -12,6 +14,10 @@ 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
@@ -55,14 +61,16 @@ export function makeRecentActivityTitleService(
       }
 
       const refinedTitle = normalizeTitle(
-        yield* Effect.tryPromise(() =>
-          helperModelRuntime.generateHelperText({
-            tag: 'recent-activity-title-refinement',
-            createAgent: createRecentActivityTitleRefinerAgent,
-            defaultSystemPrompt: RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
-            timeoutMs: RECENT_ACTIVITY_TITLE_TIMEOUT_MS,
-            messages: [{ role: 'user', content: promptInput }],
-          }),
+        yield* tryRecentActivityTitlePromise(
+          () =>
+            helperModelRuntime.generateHelperText({
+              tag: 'recent-activity-title-refinement',
+              createAgent: createRecentActivityTitleRefinerAgent,
+              defaultSystemPrompt: RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
+              timeoutMs: RECENT_ACTIVITY_TITLE_TIMEOUT_MS,
+              messages: [{ role: 'user', content: promptInput }],
+            }),
+          'Failed to generate recent activity title refinement.',
         ),
       )
       if (
@@ -84,7 +92,7 @@ export function makeRecentActivityTitleService(
 export class RecentActivityTitleServiceTag extends Context.Service<
   RecentActivityTitleServiceTag,
   ReturnType<typeof makeRecentActivityTitleService>
->()('RecentActivityTitleService') {}
+>()('@lota-sdk/core/RecentActivityTitleService') {}
 
 export const RecentActivityTitleServiceLive = Layer.effect(
   RecentActivityTitleServiceTag,

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

@@ -387,7 +387,7 @@ export function makeRecentActivityService(db: SurrealDBService) {
 export class RecentActivityServiceTag extends Context.Service<
   RecentActivityServiceTag,
   ReturnType<typeof makeRecentActivityService>
->()('RecentActivityService') {}
+>()('@lota-sdk/core/RecentActivityService') {}
 
 export const RecentActivityServiceLive = Layer.effect(
   RecentActivityServiceTag,

package/src/services/skill-resolver.service.ts

@@ -33,7 +33,7 @@ export function makeSkillResolverService(deps: {
 }
 
 export class SkillResolverServiceTag extends Context.Service<SkillResolverServiceTag, SkillResolverService>()(
-  'SkillResolverService',
+  '@lota-sdk/core/SkillResolverService',
 ) {}
 
 export const SkillResolverServiceLive = Layer.effect(

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

@@ -1,12 +1,22 @@
 import { normalizeMessageBatch } from '@lota-sdk/shared'
-import { Context, Effect, Layer } from 'effect'
+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',
+  { 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'])
@@ -57,6 +67,8 @@ const SocialChatHistoryMessageSchema = z.object({
   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>
@@ -101,7 +113,7 @@ export function makeSocialChatHistoryService(
   const parseStoredMessageEffect = (value: string | null): Effect.Effect<SocialChatHistoryMessage | null> => {
     if (!value) return Effect.succeed(null)
 
-    return Effect.try({ try: (): unknown => JSON.parse(value), catch: (cause) => cause }).pipe(
+    return decodeJsonStringEffect(value).pipe(
       Effect.map((parsed) => {
         const validated = SocialChatHistoryMessageSchema.safeParse(parsed)
         return validated.success ? validated.data : null
@@ -116,9 +128,9 @@ export function makeSocialChatHistoryService(
   const parseCursorEffect = (value: string | null): Effect.Effect<LotaRuntimeBackgroundCursor | null> => {
     if (!value) return Effect.succeed(null)
 
-    return Effect.try({ try: (): unknown => JSON.parse(value), catch: (cause) => cause }).pipe(
+    return decodeJsonStringEffect(value).pipe(
       Effect.map((parsed) => {
-        const validated = z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) }).safeParse(parsed)
+        const validated = SocialChatHistoryCursorSchema.safeParse(parsed)
         return validated.success ? validated.data : null
       }),
       Effect.catch(() => Effect.succeed(null)),
@@ -145,19 +157,20 @@ export function makeSocialChatHistoryService(
         multi.zadd(workspaceIndexKey(message.workspaceId), score, storageKey)
       }
 
-      yield* Effect.tryPromise(() => multi.exec())
+      yield* tryRedisPromise(() => multi.exec(), 'Failed to upsert social chat messages.')
       return normalizedMessages
     })
 
   const listThreadMessagesEffect = (params: { workspaceId: string; threadId: string }) =>
     Effect.gen(function* () {
       const conn = redis.getConnection()
-      const storageKeys = yield* Effect.tryPromise(() =>
-        conn.zrange(threadIndexKey(params.workspaceId, params.threadId), 0, -1),
+      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 = yield* Effect.tryPromise(() => conn.mget(storageKeys))
+      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)
@@ -175,14 +188,16 @@ export function makeSocialChatHistoryService(
       const scoreStart =
         params.cursor?.createdAt.getTime() ??
         (params.onboardingCutoff ? params.onboardingCutoff.getTime() : Number.NEGATIVE_INFINITY)
-      const storageKeys = yield* Effect.tryPromise(() =>
-        params.cursor || params.onboardingCutoff
-          ? conn.zrangebyscore(indexKey, scoreStart, '+inf')
-          : conn.zrange(indexKey, 0, -1),
+      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* Effect.tryPromise(() => conn.mget(storageKeys))
+      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)
@@ -210,18 +225,20 @@ export function makeSocialChatHistoryService(
     }).pipe(Effect.map((messages) => messages.length > 0))
 
   const getBackgroundCursorEffect = (kind: LotaRuntimeBackgroundCursorKind, workspaceId: string) =>
-    Effect.tryPromise(() => redis.getConnection().get(cursorKey(kind, workspaceId))).pipe(
-      Effect.flatMap((value) => parseCursorEffect(value)),
-    )
+    tryRedisPromise(
+      () => redis.getConnection().get(cursorKey(kind, workspaceId)),
+      'Failed to read background cursor.',
+    ).pipe(Effect.flatMap((value) => parseCursorEffect(value)))
 
   const setBackgroundCursorEffect = (
     kind: LotaRuntimeBackgroundCursorKind,
     workspaceId: string,
     cursor: LotaRuntimeBackgroundCursor,
   ) =>
-    Effect.tryPromise(() => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor))).pipe(
-      Effect.asVoid,
-    )
+    tryRedisPromise(
+      () => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor)),
+      'Failed to write background cursor.',
+    ).pipe(Effect.asVoid)
 
   return {
     upsertMessages: upsertMessagesEffect,
@@ -236,7 +253,7 @@ export function makeSocialChatHistoryService(
 export class SocialChatHistoryServiceTag extends Context.Service<
   SocialChatHistoryServiceTag,
   ReturnType<typeof makeSocialChatHistoryService>
->()('SocialChatHistoryService') {}
+>()('@lota-sdk/core/SocialChatHistoryService') {}
 
 export const SocialChatHistoryServiceLive = Layer.effect(
   SocialChatHistoryServiceTag,