@lota-sdk/core 0.4.13 → 0.4.15

package/src/services/thread/thread.service.ts

@@ -10,7 +10,6 @@ import type { RecordIdRef } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { BadRequestError, ServiceError } from '../../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import {
   AgentConfigServiceTag,
   DatabaseServiceTag,
@@ -20,7 +19,7 @@ import {
 import type { RedisConnectionManager } from '../../redis/connection'
 import { CompactionCoordinationTag } from '../../runtime/chat-run-orchestration'
 import { toIsoDateTimeString } from '../../utils/date-time'
-import { BackgroundWorkService } from '../background-work.service'
+import { BackgroundWorkServiceTag } from '../background-work.service'
 import { ChatRunRegistryTag } from '../chat-run-registry.service'
 import { ContextCompactionServiceTag } from '../context-compaction.service'
 import type { makeContextCompactionService } from '../context-compaction.service'
@@ -63,8 +62,6 @@ function toPublicThread(thread: NormalizedThread): PublicThread {
 
 type ThreadServiceError = ServiceError | BadRequestError
 
-const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
-
 type ChatRunRegistry = Context.Service.Shape<typeof ChatRunRegistryTag>
 
 type CompactionCoordination = Context.Service.Shape<typeof CompactionCoordinationTag>
@@ -78,7 +75,7 @@ interface ThreadServiceDeps {
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   contextCompactionService: ReturnType<typeof makeContextCompactionService>
   compactionCoordination: CompactionCoordination
-  background: Context.Service.Shape<typeof BackgroundWorkService>
+  background: Context.Service.Shape<typeof BackgroundWorkServiceTag>
 }
 
 export function makeThreadService(deps: ThreadServiceDeps) {
@@ -109,10 +106,11 @@ export function makeThreadService(deps: ThreadServiceDeps) {
       return Effect.succeed(true)
     }
 
-    return effectTryPromise(
-      () => activeRun.hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD)),
-      'Failed to check active thread run lease.',
-    )
+    return activeRun
+      .hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD))
+      .pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to check active thread run lease.', cause })),
+      )
   }
 
   function toNormalizedThread(
@@ -174,68 +172,59 @@ export function makeThreadService(deps: ThreadServiceDeps) {
     background: deps.background,
   })
 
-  function getById(threadId: RecordIdRef) {
-    return effectTryPromise(() => threadStore.getById(threadId), 'Failed to load thread.')
-  }
+  const getById = Effect.fn('ThreadService.getById')(function* (threadId: RecordIdRef) {
+    return yield* threadStore
+      .getById(threadId)
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to load thread.', cause })))
+  })
 
-  function getThread(threadId: RecordIdRef) {
-    return Effect.gen(function* () {
-      const thread = yield* getById(threadId)
-      return yield* toNormalizedThread(thread)
-    })
-  }
+  const getThread = Effect.fn('ThreadService.getThread')(function* (threadId: RecordIdRef) {
+    const thread = yield* getById(threadId)
+    return yield* toNormalizedThread(thread)
+  })
 
-  function updateTitle(threadId: RecordIdRef, title: string) {
-    return Effect.gen(function* () {
-      const existing = yield* getById(threadId)
-      yield* assertMutableThreadEffect(existing)
-      const thread = yield* effectTryPromise(
-        () => threadStore.update(threadId, { title, nameGenerated: true }),
-        'Failed to update thread title.',
-      )
-      return yield* toNormalizedThread(thread)
-    })
-  }
+  const updateTitle = Effect.fn('ThreadService.updateTitle')(function* (threadId: RecordIdRef, title: string) {
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    const thread = yield* threadStore
+      .update(threadId, { title, nameGenerated: true })
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread title.', cause })))
+    return yield* toNormalizedThread(thread)
+  })
 
-  function updateStatus(threadId: RecordIdRef, status: string) {
-    return Effect.gen(function* () {
-      const parsedStatus = sdkThreadStatusSchema.safeParse(status)
-      if (!parsedStatus.success) {
-        return yield* new BadRequestError({ message: `Invalid thread status: ${status}` })
-      }
-      const existing = yield* getById(threadId)
-      yield* assertMutableThreadEffect(existing)
-      const thread = yield* effectTryPromise(
-        () => threadStore.update(threadId, { status: parsedStatus.data }),
-        'Failed to update thread status.',
-      )
-      return yield* toNormalizedThread(thread)
-    })
-  }
+  const updateStatus = Effect.fn('ThreadService.updateStatus')(function* (threadId: RecordIdRef, status: string) {
+    const parsedStatus = sdkThreadStatusSchema.safeParse(status)
+    if (!parsedStatus.success) {
+      return yield* new BadRequestError({ message: `Invalid thread status: ${status}` })
+    }
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    const thread = yield* threadStore
+      .update(threadId, { status: parsedStatus.data })
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread status.', cause })))
+    return yield* toNormalizedThread(thread)
+  })
 
-  function setCompacting(threadId: RecordIdRef, value: boolean) {
+  const setCompacting = Effect.fn('ThreadService.setCompacting')(function* (threadId: RecordIdRef, value: boolean) {
     const threadRef = ensureRecordId(threadId, TABLES.THREAD)
     const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
-    return Effect.asVoid(
-      effectTryPromise(
-        () => deps.db.query<unknown>(surql`UPDATE ONLY ${threadRef} SET isCompacting = ${value}`),
-        'Failed to update thread compaction flag.',
-      ).pipe(Effect.tap(() => deps.compactionCoordination.signal(threadIdString, value))),
-    )
-  }
-
-  function clearThread(threadId: RecordIdRef) {
-    return Effect.gen(function* () {
-      const existing = yield* getById(threadId)
-      yield* assertMutableThreadEffect(existing)
-      const threadRef = ensureRecordId(threadId, TABLES.THREAD)
-      yield* effectTryPromise(
-        () => deps.db.deleteWhere(TABLES.THREAD_MESSAGE, { threadId: threadRef }),
-        'Failed to delete thread messages.',
+    yield* deps.db
+      .query<unknown>(surql`UPDATE ONLY ${threadRef} SET isCompacting = ${value}`)
+      .pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread compaction flag.', cause })),
       )
-      yield* effectTryPromise(
-        () =>
-          deps.db.query<unknown>(surql`
+    yield* deps.compactionCoordination.signal(threadIdString, value)
+  })
+
+  const clearThread = Effect.fn('ThreadService.clearThread')(function* (threadId: RecordIdRef) {
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    yield* deps.db
+      .deleteWhere(TABLES.THREAD_MESSAGE, { threadId: threadRef })
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to delete thread messages.', cause })))
+    yield* deps.db
+      .query<unknown>(surql`
           UPDATE ONLY ${threadRef}
           SET turnCount = 0,
               compactionSummary = NONE,
@@ -243,68 +232,102 @@ export function makeThreadService(deps: ThreadServiceDeps) {
               activeRunId = NONE,
               activeStreamId = NONE,
               isCompacting = false
-        `),
-        'Failed to reset thread state.',
-      )
-    })
-  }
+        `)
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to reset thread state.', cause })))
+  })
 
-  function deleteThread(threadId: RecordIdRef) {
-    return Effect.gen(function* () {
-      const existing = yield* getById(threadId)
-      yield* assertMutableThreadEffect(existing)
-      yield* effectTryPromise(() => threadStore.deleteById(threadId), 'Failed to delete thread.')
-    })
-  }
+  const deleteThread = Effect.fn('ThreadService.deleteThread')(function* (threadId: RecordIdRef) {
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    yield* threadStore
+      .deleteById(threadId)
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to delete thread.', cause })))
+  })
 
   function incrementTurnCount(threadId: RecordIdRef) {
     const threadRef = ensureRecordId(threadId, TABLES.THREAD)
     return Effect.gen(function* () {
-      const result = yield* effectTryPromise(
-        () =>
-          deps.db.query<{ turnCount: number }>(
-            surql`
+      const result = yield* deps.db
+        .query<{ turnCount: number }>(
+          surql`
         UPDATE ONLY ${threadRef}
         SET turnCount += 1
         RETURN turnCount
       `,
-          ),
-        'Failed to increment thread turn count.',
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) => new ServiceError({ message: 'Failed to increment thread turn count.', cause })),
+        )
       return result[0].turnCount
     })
   }
 
   return {
     findById: (...args: Parameters<typeof threadStore.findById>) =>
-      effectTryPromise(() => threadStore.findById(...args), 'Failed to find thread.'),
+      threadStore.findById(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to find thread.', cause })),
+        Effect.withSpan('ThreadService.findById'),
+      ),
     getById,
     findAll: (...args: Parameters<typeof threadStore.findAll>) =>
-      effectTryPromise(() => threadStore.findAll(...args), 'Failed to find all threads.'),
+      threadStore.findAll(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to find all threads.', cause })),
+        Effect.withSpan('ThreadService.findAll'),
+      ),
     create: (...args: Parameters<typeof threadStore.create>) =>
-      effectTryPromise(() => threadStore.create(...args), 'Failed to create thread.'),
+      threadStore.create(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to create thread.', cause })),
+        Effect.withSpan('ThreadService.create'),
+      ),
     update: (...args: Parameters<typeof threadStore.update>) =>
-      effectTryPromise(() => threadStore.update(...args), 'Failed to update thread.'),
+      threadStore.update(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread.', cause })),
+        Effect.withSpan('ThreadService.update'),
+      ),
     delete: (...args: Parameters<typeof threadStore.deleteById>) =>
-      effectTryPromise(() => threadStore.deleteById(...args), 'Failed to delete thread.'),
+      threadStore.deleteById(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to delete thread.', cause })),
+        Effect.withSpan('ThreadService.delete'),
+      ),
     getOrCreateDefault: (...args: Parameters<typeof bootstrap.getOrCreateDefault>) =>
-      effectTryPromise(() => bootstrap.getOrCreateDefault(...args), 'Failed to get or create default thread.'),
+      bootstrap.getOrCreateDefault(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to get or create default thread.', cause })),
+        Effect.withSpan('ThreadService.getOrCreateDefault'),
+      ),
     getOrCreateThread: (...args: Parameters<typeof bootstrap.getOrCreateThread>) =>
-      effectTryPromise(() => bootstrap.getOrCreateThread(...args), 'Failed to get or create thread.'),
+      bootstrap.getOrCreateThread(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to get or create thread.', cause })),
+        Effect.withSpan('ThreadService.getOrCreateThread'),
+      ),
     createThread: (...args: Parameters<typeof bootstrap.createThread>) =>
-      effectTryPromise(() => bootstrap.createThread(...args), 'Failed to create thread.'),
+      bootstrap.createThread(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to create thread.', cause })),
+        Effect.withSpan('ThreadService.createThread'),
+      ),
     ensureBootstrapThreads: (...args: Parameters<typeof bootstrap.ensureBootstrapThreads>) =>
-      effectTryPromise(() => bootstrap.ensureBootstrapThreads(...args), 'Failed to ensure bootstrap threads.'),
+      bootstrap.ensureBootstrapThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to ensure bootstrap threads.', cause })),
+        Effect.withSpan('ThreadService.ensureBootstrapThreads'),
+      ),
     listThreads: (...args: Parameters<typeof listing.listThreads>) =>
-      effectTryPromise(() => listing.listThreads(...args), 'Failed to list threads.'),
+      listing.listThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to list threads.', cause })),
+        Effect.withSpan('ThreadService.listThreads'),
+      ),
     listOrganizationThreads: (...args: Parameters<typeof listing.listOrganizationThreads>) =>
-      effectTryPromise(() => listing.listOrganizationThreads(...args), 'Failed to list organization threads.'),
+      listing.listOrganizationThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to list organization threads.', cause })),
+        Effect.withSpan('ThreadService.listOrganizationThreads'),
+      ),
     getThread,
     updateTitle,
     updateStatus,
     setActiveTurn: activeRun.setActiveTurn,
     getActiveTurn: (...args: Parameters<typeof activeRun.getActiveTurn>) =>
-      effectTryPromise(() => activeRun.getActiveTurn(...args), 'Failed to get active turn.'),
+      activeRun.getActiveTurn(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to get active turn.', cause })),
+        Effect.withSpan('ThreadService.getActiveTurn'),
+      ),
     getActiveRunId: activeRun.getActiveRunId,
     hasActiveRunLease: activeRun.hasActiveRunLease,
     withActiveRunLease: activeRun.withActiveRunLease,
@@ -312,16 +335,28 @@ export function makeThreadService(deps: ThreadServiceDeps) {
     clearActiveTurn: activeRun.clearActiveTurn,
     clearStaleActiveRunIfMissingFromRegistry: activeRun.clearStaleActiveRunIfMissingFromRegistry,
     stopActiveRun: (...args: Parameters<typeof activeRun.stopActiveRun>) =>
-      effectTryPromise(() => activeRun.stopActiveRun(...args), 'Failed to stop active run.'),
+      activeRun.stopActiveRun(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to stop active run.', cause })),
+        Effect.withSpan('ThreadService.stopActiveRun'),
+      ),
     setCompacting,
     appendMemoryBlock: (...args: Parameters<typeof memory.appendMemoryBlock>) =>
-      effectTryPromise(() => memory.appendMemoryBlock(...args), 'Failed to append memory block.'),
+      memory.appendMemoryBlock(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to append memory block.', cause })),
+        Effect.withSpan('ThreadService.appendMemoryBlock'),
+      ),
     compactMemoryBlock: (...args: Parameters<typeof memory.compactMemoryBlock>) =>
-      effectTryPromise(() => memory.compactMemoryBlock(...args), 'Failed to compact memory block.'),
+      memory.compactMemoryBlock(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to compact memory block.', cause })),
+        Effect.withSpan('ThreadService.compactMemoryBlock'),
+      ),
     clearThread,
     deleteThread,
     listRecentThreads: (...args: Parameters<typeof listing.listRecentThreads>) =>
-      effectTryPromise(() => listing.listRecentThreads(...args), 'Failed to list recent threads.'),
+      listing.listRecentThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to list recent threads.', cause })),
+        Effect.withSpan('ThreadService.listRecentThreads'),
+      ),
     formatMemoryBlockForPrompt,
     toPublicThread,
     incrementTurnCount,
@@ -343,7 +378,7 @@ export const ThreadServiceLive = Layer.effect(
     const threadMessageService = yield* ThreadMessageServiceTag
     const contextCompactionService = yield* ContextCompactionServiceTag
     const compactionCoordination = yield* CompactionCoordinationTag
-    const background = yield* BackgroundWorkService
+    const background = yield* BackgroundWorkServiceTag
     return makeThreadService({
       agentConfig,
       threadBootstrapConfig,

package/src/services/user.service.ts

@@ -6,7 +6,7 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { NotFoundError } from '../effect/errors'
+import { ERROR_TAGS, NotFoundError } from '../effect/errors'
 import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString } from '../utils/date-time'
 
@@ -28,7 +28,7 @@ function userNotFoundError(userId: RecordIdInput): NotFoundError {
   })
 }
 
-class UserServiceError extends Schema.TaggedErrorClass<UserServiceError>()('UserServiceError', {
+class UserServiceError extends Schema.TaggedErrorClass<UserServiceError>()(ERROR_TAGS.UserServiceError, {
   operation: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -38,59 +38,56 @@ function toUserServiceError(operation: string, cause: unknown): UserServiceError
 }
 
 export function makeUserService(db: SurrealDBService) {
-  function upsertUserEffect(params: { id: RecordIdInput; name: string; email: string }) {
+  const upsertUser = Effect.fn('UserService.upsertUser')(function* (params: {
+    id: RecordIdInput
+    name: string
+    email: string
+  }) {
     const userRef = ensureRecordId(params.id, TABLES.USER)
-    return db.upsert(TABLES.USER, userRef, { name: params.name, email: params.email }, sdkUserRecordSchema).pipe(
-      Effect.mapError((cause) => toUserServiceError('upsertUser', cause)),
-      Effect.map(toPublic),
-    )
-  }
+    const record = yield* db
+      .upsert(TABLES.USER, userRef, { name: params.name, email: params.email }, sdkUserRecordSchema)
+      .pipe(Effect.mapError((cause) => toUserServiceError('upsertUser', cause)))
+    return toPublic(record)
+  })
 
-  function getUserEffect(userId: RecordIdInput) {
-    return db.findOne(TABLES.USER, { id: ensureRecordId(userId, TABLES.USER) }, sdkUserRecordSchema).pipe(
-      Effect.mapError((cause) => toUserServiceError('getUser', cause)),
-      Effect.flatMap((record) => (record ? Effect.succeed(record) : Effect.fail(userNotFoundError(userId)))),
-      Effect.map(toPublic),
-    )
-  }
+  const getUser = Effect.fn('UserService.getUser')(function* (userId: RecordIdInput) {
+    const record = yield* db
+      .findOne(TABLES.USER, { id: ensureRecordId(userId, TABLES.USER) }, sdkUserRecordSchema)
+      .pipe(Effect.mapError((cause) => toUserServiceError('getUser', cause)))
+    if (!record) return yield* userNotFoundError(userId)
+    return toPublic(record)
+  })
 
-  function listUsersEffect() {
-    return db.findMany(TABLES.USER, {}, sdkUserRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' }).pipe(
-      Effect.mapError((cause) => toUserServiceError('listUsers', cause)),
-      Effect.map((records) => records.map(toPublic)),
-    )
-  }
+  const listUsers = Effect.fn('UserService.listUsers')(function* () {
+    const records = yield* db
+      .findMany(TABLES.USER, {}, sdkUserRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' })
+      .pipe(Effect.mapError((cause) => toUserServiceError('listUsers', cause)))
+    return records.map(toPublic)
+  })
 
-  function updateUserEffect(userId: RecordIdInput, params: { name?: string; email?: string }) {
-    return db.update(TABLES.USER, ensureRecordId(userId, TABLES.USER), params, sdkUserRecordSchema).pipe(
-      Effect.mapError((cause) => toUserServiceError('updateUser', cause)),
-      Effect.flatMap((updated) => (updated ? Effect.succeed(updated) : Effect.fail(userNotFoundError(userId)))),
-      Effect.map(toPublic),
-    )
-  }
+  const updateUser = Effect.fn('UserService.updateUser')(function* (
+    userId: RecordIdInput,
+    params: { name?: string; email?: string },
+  ) {
+    const updated = yield* db
+      .update(TABLES.USER, ensureRecordId(userId, TABLES.USER), params, sdkUserRecordSchema)
+      .pipe(Effect.mapError((cause) => toUserServiceError('updateUser', cause)))
+    if (!updated) return yield* userNotFoundError(userId)
+    return toPublic(updated)
+  })
 
-  function deleteUserEffect(userId: RecordIdInput) {
+  const deleteUser = Effect.fn('UserService.deleteUser')(function* (userId: RecordIdInput) {
     const userRef = ensureRecordId(userId, TABLES.USER)
-    return Effect.gen(function* () {
-      yield* db
-        .deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
-        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteMemberships', cause)))
-      const deleted = yield* db
-        .deleteById(TABLES.USER, userRef)
-        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteUser', cause)))
-      if (!deleted) {
-        return yield* userNotFoundError(userId)
-      }
-    })
-  }
+    yield* db
+      .deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
+      .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteMemberships', cause)))
+    const deleted = yield* db
+      .deleteById(TABLES.USER, userRef)
+      .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteUser', cause)))
+    if (!deleted) return yield* userNotFoundError(userId)
+  })
 
-  return {
-    upsertUser: upsertUserEffect,
-    getUser: getUserEffect,
-    listUsers: listUsersEffect,
-    updateUser: updateUserEffect,
-    deleteUser: deleteUserEffect,
-  }
+  return { upsertUser, getUser, listUsers, updateUser, deleteUser }
 }
 
 export class UserServiceTag extends Context.Service<UserServiceTag, ReturnType<typeof makeUserService>>()(

package/src/storage/attachment-parser.ts

@@ -3,9 +3,11 @@ import { Schema, Effect } from 'effect'
 import mammoth from 'mammoth'
 import { PDFParse } from 'pdf-parse'
 
+import { ERROR_TAGS } from '../effect/errors'
+
 const READ_FILE_PARTS_CHARS_PER_PAGE = 3500
 
-class AttachmentParserError extends Schema.TaggedErrorClass<AttachmentParserError>()('AttachmentParserError', {
+class AttachmentParserError extends Schema.TaggedErrorClass<AttachmentParserError>()(ERROR_TAGS.AttachmentParserError, {
   message: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -67,7 +69,9 @@ export function extractPdfPages(file: File): Promise<string[]> {
       }).pipe(
         Effect.ensuring(
           tryAttachmentPromise('Failed to destroy PDF parser.', () => parser.destroy()).pipe(
-            Effect.orDie,
+            Effect.catchTag(ERROR_TAGS.AttachmentParserError, (error) =>
+              Effect.logWarning(`Attachment parser cleanup failed: ${error.message}`),
+            ),
             Effect.asVoid,
           ),
         ),

package/src/storage/attachment-storage.service.ts

@@ -3,7 +3,7 @@ import { S3Client } from 'bun'
 import { Context, Schema, Effect, Layer } from 'effect'
 
 import { serverLogger } from '../config/logger'
-import { BadRequestError, ForbiddenError } from '../effect/errors'
+import { ERROR_TAGS, BadRequestError, ForbiddenError } from '../effect/errors'
 import { RuntimeConfigServiceTag } from '../effect/services'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import { getErrorMessage } from '../utils/errors'
@@ -36,11 +36,10 @@ export type UploadedThreadAttachment = {
 
 type AttachmentContextCandidate = { storageKey: string; name: string; contentType: string; sizeBytes: number | null }
 
-class AttachmentStorageError extends Schema.TaggedErrorClass<AttachmentStorageError>()('AttachmentStorageError', {
-  operation: Schema.String,
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class AttachmentStorageError extends Schema.TaggedErrorClass<AttachmentStorageError>()(
+  ERROR_TAGS.AttachmentStorageError,
+  { operation: Schema.String, message: Schema.String, cause: Schema.Defect },
+) {}
 
 function toAttachmentStorageError(operation: string, cause: unknown): AttachmentStorageError {
   return new AttachmentStorageError({ operation, message: getErrorMessage(cause), cause })

package/src/storage/generated-document-storage.service.ts

@@ -26,7 +26,7 @@ function buildGeneratedDocumentStorageKey(params: {
 }
 
 class GeneratedDocumentStorageError extends Schema.TaggedErrorClass<GeneratedDocumentStorageError>()(
-  'GeneratedDocumentStorageError',
+  '@lota-sdk/core/GeneratedDocumentStorageError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 

package/src/system-agents/context-compaction.agent.ts

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -31,12 +31,13 @@ The caller enforces a structured output schema with exactly one field:
 </output-format>
 </agent-instructions>`
 
-export function createContextCompactionAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'context-compaction',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, { instructions: CONTEXT_COMPACTION_PROMPT }),
-  })
+export function makeContextCompactionAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'context-compaction',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, { instructions: CONTEXT_COMPACTION_PROMPT }),
+    })
 }