@lota-sdk/core 0.4.13 → 0.4.14

package/src/services/thread/thread-listing.ts

@@ -6,7 +6,7 @@ import type { RecordIdRef } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import type { BadRequestError, ServiceError } from '../../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { ThreadSchema } from './thread.types'
 import type { NormalizedThread, ThreadRecord } from './thread.types'
 
@@ -41,15 +41,11 @@ export function createThreadListingHelpers(deps: {
     options?: { checkLease?: boolean },
   ): Effect.Effect<NormalizedThread[], BadRequestError | ServiceError>
 }) {
-  class ThreadListingError extends Schema.TaggedErrorClass<ThreadListingError>()('ThreadListingError', {
+  class ThreadListingError extends Schema.TaggedErrorClass<ThreadListingError>()(ERROR_TAGS.ThreadListingError, {
     message: Schema.String,
     cause: Schema.optional(Schema.Defect),
   }) {}
 
-  const effectTryPromise = makeEffectTryPromiseWithMessage(
-    (message, cause) => new ThreadListingError({ message, cause }),
-  )
-
   function listThreads(
     userId: RecordIdRef,
     orgId: RecordIdRef,
@@ -62,18 +58,19 @@ export function createThreadListingHelpers(deps: {
     if (type === 'default' || type === 'thread') {
       const vars: Record<string, unknown> = { userId, orgId, type }
       return Effect.gen(function* () {
-        const threads = yield* effectTryPromise(
-          () =>
-            deps.db.queryMany(
-              new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: false, type }), vars),
-              ThreadSchema,
+        const threads = yield* deps.db
+          .queryMany(
+            new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: false, type }), vars),
+            ThreadSchema,
+          )
+          .pipe(Effect.mapError((cause) => new ThreadListingError({ message: 'Failed to list threads.', cause })))
+        const normalizedThreads = yield* deps
+          .normalizeThreads(threads, { checkLease: false })
+          .pipe(
+            Effect.mapError(
+              (cause) => new ThreadListingError({ message: 'Failed to normalize listed threads.', cause }),
             ),
-          'Failed to list threads.',
-        )
-        const normalizedThreads = yield* effectTryPromise(
-          () => deps.normalizeThreads(threads, { checkLease: false }),
-          'Failed to normalize listed threads.',
-        )
+          )
         return { threads: normalizedThreads, hasMore: false }
       })
     }
@@ -89,20 +86,23 @@ export function createThreadListingHelpers(deps: {
     }
 
     return Effect.gen(function* () {
-      const threads = yield* effectTryPromise(
-        () =>
-          deps.db.queryMany(
-            new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: true, type, types }), vars),
-            ThreadSchema,
-          ),
-        'Failed to list paginated threads.',
-      )
+      const threads = yield* deps.db
+        .queryMany(
+          new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: true, type, types }), vars),
+          ThreadSchema,
+        )
+        .pipe(
+          Effect.mapError((cause) => new ThreadListingError({ message: 'Failed to list paginated threads.', cause })),
+        )
       const hasMore = threads.length > take
       const sliced = hasMore ? threads.slice(0, take) : threads
-      const normalizedThreads = yield* effectTryPromise(
-        () => deps.normalizeThreads(sliced, { checkLease: false }),
-        'Failed to normalize paginated threads.',
-      )
+      const normalizedThreads = yield* deps
+        .normalizeThreads(sliced, { checkLease: false })
+        .pipe(
+          Effect.mapError(
+            (cause) => new ThreadListingError({ message: 'Failed to normalize paginated threads.', cause }),
+          ),
+        )
       return { threads: normalizedThreads, hasMore }
     })
   }
@@ -131,23 +131,28 @@ export function createThreadListingHelpers(deps: {
     }
 
     return Effect.gen(function* () {
-      const threads = yield* effectTryPromise(
-        () =>
-          deps.db.queryMany(
-            new BoundQuery(
-              `SELECT * FROM ${TABLES.THREAD}
+      const threads = yield* deps.db
+        .queryMany(
+          new BoundQuery(
+            `SELECT * FROM ${TABLES.THREAD}
          WHERE ${whereClauses.join('\n           AND ')}
          ORDER BY createdAt ASC, id ASC`,
-              variables,
-            ),
-            ThreadSchema,
+            variables,
+          ),
+          ThreadSchema,
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) => new ThreadListingError({ message: 'Failed to list organization threads.', cause }),
+          ),
+        )
+      return yield* deps
+        .normalizeThreads(threads, { checkLease: false })
+        .pipe(
+          Effect.mapError(
+            (cause) => new ThreadListingError({ message: 'Failed to normalize organization threads.', cause }),
           ),
-        'Failed to list organization threads.',
-      )
-      return yield* effectTryPromise(
-        () => deps.normalizeThreads(threads, { checkLease: false }),
-        'Failed to normalize organization threads.',
-      )
+        )
     })
   }
 
@@ -171,27 +176,26 @@ export function createThreadListingHelpers(deps: {
     }
 
     return Effect.gen(function* () {
-      const threads = yield* effectTryPromise(
-        () =>
-          deps.db.queryMany(
-            new BoundQuery(
-              `SELECT * FROM ${TABLES.THREAD}
+      const threads = yield* deps.db
+        .queryMany(
+          new BoundQuery(
+            `SELECT * FROM ${TABLES.THREAD}
 	       WHERE userId = $userId
 	         AND organizationId = $orgId
 	         ${excludeCondition}
 	         AND status != "archived"
 	       ORDER BY updatedAt DESC
 	       LIMIT $limit`,
-              vars,
-            ),
-            ThreadSchema,
+            vars,
           ),
-        'Failed to list recent threads.',
-      )
-      return yield* effectTryPromise(
-        () => deps.normalizeThreads(threads, { checkLease: false }),
-        'Failed to normalize recent threads.',
-      )
+          ThreadSchema,
+        )
+        .pipe(Effect.mapError((cause) => new ThreadListingError({ message: 'Failed to list recent threads.', cause })))
+      return yield* deps
+        .normalizeThreads(threads, { checkLease: false })
+        .pipe(
+          Effect.mapError((cause) => new ThreadListingError({ message: 'Failed to normalize recent threads.', cause })),
+        )
     })
   }
 

package/src/services/thread/thread-memory-block.ts

@@ -5,7 +5,7 @@ import { serverLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import {
   appendToMemoryBlock,
   compactMemoryBlockEntries,
@@ -14,7 +14,7 @@ import {
   parseMemoryBlock,
   serializeMemoryBlock,
 } from '../../runtime/memory/memory-block'
-import type { BackgroundWorkService } from '../background-work.service'
+import type { BackgroundWorkServiceTag } from '../background-work.service'
 import type { makeContextCompactionService } from '../context-compaction.service'
 import { MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES, MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES } from './thread-constants'
 import type { ThreadRecordStore } from './thread-record-store'
@@ -22,16 +22,12 @@ import type { ThreadRecord } from './thread.types'
 
 type ContextCompactionServiceLike = Pick<ReturnType<typeof makeContextCompactionService>, 'compactMemoryBlock'>
 
-type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkServiceTag>
 
-class ThreadMemoryBlockError extends Schema.TaggedErrorClass<ThreadMemoryBlockError>()('ThreadMemoryBlockError', {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
-
-const tryThreadMemoryBlockEffect = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ThreadMemoryBlockError({ message, cause }),
-)
+class ThreadMemoryBlockError extends Schema.TaggedErrorClass<ThreadMemoryBlockError>()(
+  ERROR_TAGS.ThreadMemoryBlockError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 export function formatMemoryBlockForPrompt(thread: Pick<ThreadRecord, 'memoryBlock' | 'memoryBlockSummary'>): string {
   return formatPersistedMemoryBlockForPrompt({
@@ -49,10 +45,17 @@ export function createThreadMemoryBlockHelpers(deps: {
     return Effect.gen(function* () {
       const threadRef = ensureRecordId(threadId, TABLES.THREAD)
       const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
-      const thread = yield* tryThreadMemoryBlockEffect(
-        () => deps.threadStore.getById(threadRef),
-        `Failed to load thread ${threadIdString} for memory block append`,
-      )
+      const thread = yield* deps.threadStore
+        .getById(threadRef)
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new ThreadMemoryBlockError({
+                message: `Failed to load thread ${threadIdString} for memory block append`,
+                cause,
+              }),
+          ),
+        )
       const entries = parseMemoryBlock(thread.memoryBlock)
 
       const labelMatch = entry.match(/^(\w+):\s*/i)
@@ -62,10 +65,17 @@ export function createThreadMemoryBlockHelpers(deps: {
       const updatedEntries = appendToMemoryBlock(entries, role, content)
       const serialized = serializeMemoryBlock(updatedEntries)
 
-      yield* tryThreadMemoryBlockEffect(
-        () => deps.threadStore.update(threadRef, { memoryBlock: serialized }),
-        `Failed to persist memory block for thread ${threadIdString}`,
-      )
+      yield* deps.threadStore
+        .update(threadRef, { memoryBlock: serialized })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new ThreadMemoryBlockError({
+                message: `Failed to persist memory block for thread ${threadIdString}`,
+                cause,
+              }),
+          ),
+        )
 
       if (updatedEntries.length >= MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES) {
         yield* deps.background.run(
@@ -88,39 +98,54 @@ export function createThreadMemoryBlockHelpers(deps: {
     return Effect.gen(function* () {
       const threadRef = ensureRecordId(threadId, TABLES.THREAD)
       const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
-      const thread = yield* tryThreadMemoryBlockEffect(
-        () => deps.threadStore.getById(threadRef),
-        `Failed to load thread ${threadIdString} for memory block compaction`,
-      )
-      const result = yield* tryThreadMemoryBlockEffect(
-        () =>
-          compactMemoryBlockEntries({
-            previousSummary: thread.memoryBlockSummary,
-            entries: parseMemoryBlock(thread.memoryBlock),
-            triggerEntries: MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES,
-            chunkEntries: MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES,
-            compact: (params) =>
-              deps.contextCompactionService
-                .compactMemoryBlock(params)
-                .pipe(
-                  Effect.mapError(
-                    (cause) => new MemoryBlockCompactError({ message: 'compact callback failed', cause }),
-                  ),
-                ),
-          }),
-        `Failed to compact memory block for thread ${threadIdString}`,
+      const thread = yield* deps.threadStore
+        .getById(threadRef)
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new ThreadMemoryBlockError({
+                message: `Failed to load thread ${threadIdString} for memory block compaction`,
+                cause,
+              }),
+          ),
+        )
+      const result = yield* compactMemoryBlockEntries({
+        previousSummary: thread.memoryBlockSummary,
+        entries: parseMemoryBlock(thread.memoryBlock),
+        triggerEntries: MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES,
+        chunkEntries: MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES,
+        compact: (params) =>
+          deps.contextCompactionService
+            .compactMemoryBlock(params)
+            .pipe(
+              Effect.mapError((cause) => new MemoryBlockCompactError({ message: 'compact callback failed', cause })),
+            ),
+      }).pipe(
+        Effect.mapError(
+          (cause) =>
+            new ThreadMemoryBlockError({
+              message: `Failed to compact memory block for thread ${threadIdString}`,
+              cause,
+            }),
+        ),
       )
 
       if (!result.compacted) return false
 
-      yield* tryThreadMemoryBlockEffect(
-        () =>
-          deps.threadStore.update(threadRef, {
-            memoryBlockSummary: result.summary || '',
-            memoryBlock: serializeMemoryBlock(result.entries),
-          }),
-        `Failed to persist compacted memory block for thread ${threadIdString}`,
-      )
+      yield* deps.threadStore
+        .update(threadRef, {
+          memoryBlockSummary: result.summary || '',
+          memoryBlock: serializeMemoryBlock(result.entries),
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new ThreadMemoryBlockError({
+                message: `Failed to persist compacted memory block for thread ${threadIdString}`,
+                cause,
+              }),
+          ),
+        )
 
       return true
     })

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

@@ -15,7 +15,6 @@ import { TABLES } from '../../db/tables'
 import { ThreadMessageRowSchema } from '../../db/thread-message-row'
 import type { ThreadMessageRow } from '../../db/thread-message-row'
 import { ServiceError } from '../../effect/errors'
-import { effectTryServicePromise } from '../../effect/helpers'
 import { AgentConfigServiceTag, DatabaseServiceTag } from '../../effect/services'
 import { sha256Hex } from '../../utils/crypto'
 import { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
@@ -128,32 +127,37 @@ export function makeThreadMessageService(db: SurrealDBService, agentConfig: Reso
         }
 
         const rowId = toThreadMessageRowId(threadId, messageId)
-        const existingRow = yield* effectTryServicePromise(
-          () => db.findOne(TABLES.THREAD_MESSAGE, { threadId, messageId }, ThreadMessageExistingRowSchema),
-          `Failed to load existing thread message "${messageId}".`,
-        )
+        const existingRow = yield* db
+          .findOne(TABLES.THREAD_MESSAGE, { threadId, messageId }, ThreadMessageExistingRowSchema)
+          .pipe(
+            Effect.mapError(
+              (cause) => new ServiceError({ message: `Failed to load existing thread message "${messageId}".`, cause }),
+            ),
+          )
         const persistedCreatedAt =
           existingRow === null ? requireTimestamp(message.metadata?.createdAt) : requireTimestamp(existingRow.createdAt)
         const metadata = withCreatedAtMetadata({ ...message.metadata, createdAt: persistedCreatedAt })
 
-        yield* effectTryServicePromise(
-          () =>
-            db.upsert(
-              TABLES.THREAD_MESSAGE,
-              rowId,
-              {
-                threadId,
-                messageId,
-                role,
-                parts,
-                metadata,
-                createdAt: existingRow ? existingRow.createdAt : unsafeDateFrom(persistedCreatedAt),
-              },
-              ThreadMessageRowSchema,
-              { mutation: 'content' },
+        yield* db
+          .upsert(
+            TABLES.THREAD_MESSAGE,
+            rowId,
+            {
+              threadId,
+              messageId,
+              role,
+              parts,
+              metadata,
+              createdAt: existingRow ? existingRow.createdAt : unsafeDateFrom(persistedCreatedAt),
+            },
+            ThreadMessageRowSchema,
+            { mutation: 'content' },
+          )
+          .pipe(
+            Effect.mapError(
+              (cause) => new ServiceError({ message: `Failed to upsert thread message "${messageId}".`, cause }),
             ),
-          `Failed to upsert thread message "${messageId}".`,
-        )
+          )
       }),
     ).pipe(Effect.asVoid)
   }
@@ -163,20 +167,19 @@ export function makeThreadMessageService(db: SurrealDBService, agentConfig: Reso
     upsertMessagesEffect: upsertMessages,
     listMessages(threadId: RecordIdRef) {
       const threadRef = toThreadRef(threadId)
-      return effectTryServicePromise(
-        () =>
-          db.query<unknown>(surql`
-        SELECT * FROM threadMessage
-        WHERE threadId = ${threadRef}
-        ORDER BY createdAt ASC, id ASC
-      `),
-        'Failed to list thread messages.',
-      ).pipe(
-        Effect.flatMap((rows) =>
-          Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listMessages')),
-        ),
-        Effect.map((rows) => rows.map((row) => toChatMessage(row))),
-      )
+      return db
+        .query<unknown>(surql`
+          SELECT * FROM threadMessage
+          WHERE threadId = ${threadRef}
+          ORDER BY createdAt ASC, id ASC
+        `)
+        .pipe(
+          Effect.mapError((cause) => new ServiceError({ message: 'Failed to list thread messages.', cause })),
+          Effect.flatMap((rows) =>
+            Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listMessages')),
+          ),
+          Effect.map((rows) => rows.map((row) => toChatMessage(row))),
+        )
     },
     listMessagesEffect(threadId: RecordIdRef) {
       return service.listMessages(threadId)
@@ -202,19 +205,21 @@ export function makeThreadMessageService(db: SurrealDBService, agentConfig: Reso
       }
 
       return Effect.gen(function* () {
-        const cursorRow = yield* effectTryServicePromise(
-          () => db.findOne(TABLES.THREAD_MESSAGE, { threadId: threadRef, messageId: cursorMessageId }, CursorRowSchema),
-          `Failed to load cursor message "${cursorMessageId}".`,
-        )
+        const cursorRow = yield* db
+          .findOne(TABLES.THREAD_MESSAGE, { threadId: threadRef, messageId: cursorMessageId }, CursorRowSchema)
+          .pipe(
+            Effect.mapError(
+              (cause) => new ServiceError({ message: `Failed to load cursor message "${cursorMessageId}".`, cause }),
+            ),
+          )
         if (!cursorRow) {
           return yield* new ServiceError({ message: `Thread cursor message not found: ${cursorMessageId}` })
         }
 
         const cursorCreatedAt = cursorRow.createdAt
         const cursorId = toThreadMessageRowId(threadRef, cursorMessageId)
-        const rows = yield* effectTryServicePromise(
-          () =>
-            db.query<unknown>(surql`
+        const rows = yield* db
+          .query<unknown>(surql`
             SELECT * FROM threadMessage
             WHERE threadId = ${threadRef}
               AND (
@@ -222,9 +227,12 @@ export function makeThreadMessageService(db: SurrealDBService, agentConfig: Reso
                 OR (createdAt = ${cursorCreatedAt} AND id > ${cursorId})
               )
             ORDER BY createdAt ASC, id ASC
-          `),
-          'Failed to list thread messages after cursor.',
-        )
+          `)
+          .pipe(
+            Effect.mapError(
+              (cause) => new ServiceError({ message: 'Failed to list thread messages after cursor.', cause }),
+            ),
+          )
         const parsedRows = yield* Effect.forEach(rows, (row) =>
           parseRowOrFail(ThreadMessageRowSchema, row, 'listMessagesAfterCursor'),
         )
@@ -237,21 +245,20 @@ export function makeThreadMessageService(db: SurrealDBService, agentConfig: Reso
 
     listRecentMessages(threadId: RecordIdRef, limit: number) {
       const threadRef = toThreadRef(threadId)
-      return effectTryServicePromise(
-        () =>
-          db.query<unknown>(surql`
-        SELECT * FROM threadMessage
-        WHERE threadId = ${threadRef}
-        ORDER BY createdAt DESC, id DESC
-        LIMIT ${Math.max(1, limit)}
-      `),
-        'Failed to list recent thread messages.',
-      ).pipe(
-        Effect.flatMap((rows) =>
-          Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listRecentMessages')),
-        ),
-        Effect.map((rows) => rows.reverse().map((row) => toChatMessage(row))),
-      )
+      return db
+        .query<unknown>(surql`
+          SELECT * FROM threadMessage
+          WHERE threadId = ${threadRef}
+          ORDER BY createdAt DESC, id DESC
+          LIMIT ${Math.max(1, limit)}
+        `)
+        .pipe(
+          Effect.mapError((cause) => new ServiceError({ message: 'Failed to list recent thread messages.', cause })),
+          Effect.flatMap((rows) =>
+            Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listRecentMessages')),
+          ),
+          Effect.map((rows) => rows.reverse().map((row) => toChatMessage(row))),
+        )
     },
     listRecentMessagesEffect(threadId: RecordIdRef, limit: number) {
       return service.listRecentMessages(threadId, limit)
@@ -331,10 +338,14 @@ export function makeThreadMessageService(db: SurrealDBService, agentConfig: Reso
     ensureBootstrapWelcomeMessage(params: { threadId: RecordIdRef; agentId: string; text: string }) {
       const threadRef = toThreadRef(params.threadId)
       return Effect.gen(function* () {
-        const existingRow = yield* effectTryServicePromise(
-          () => db.findOne(TABLES.THREAD_MESSAGE, { threadId: threadRef }, ThreadMessageExistingRowSchema),
-          'Failed to check for existing bootstrap welcome message.',
-        )
+        const existingRow = yield* db
+          .findOne(TABLES.THREAD_MESSAGE, { threadId: threadRef }, ThreadMessageExistingRowSchema)
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new ServiceError({ message: 'Failed to check for existing bootstrap welcome message.', cause }),
+            ),
+          )
         if (existingRow) return
 
         const messageText = params.text.trim()

package/src/services/thread/thread-record-store.ts

@@ -136,19 +136,19 @@ export function createThreadRecordStore(deps: { db: SurrealDBService }): ThreadR
     params: UniqueThreadLookupParams,
   ): Effect.Effect<ThreadRecord, NotFoundError | DatabaseError> {
     const poll = findThreadByUniqueLookup(params).pipe(
-      Effect.flatMap((result) => (result ? Effect.succeed(result) : Effect.fail('not_found' as const))),
+      Effect.flatMap((result) =>
+        result
+          ? Effect.succeed(result)
+          : Effect.fail(
+              new NotFoundError({ resource: TABLES.THREAD, message: buildExistingThreadLookupMessage(params) }),
+            ),
+      ),
     )
 
     return Effect.retry(poll, {
       times: THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS - 1,
       schedule: Schedule.fixed(Duration.millis(THREAD_UNIQUE_LOOKUP_RETRY_DELAY_MS)),
-    }).pipe(
-      Effect.mapError((error) =>
-        error === 'not_found'
-          ? new NotFoundError({ resource: TABLES.THREAD, message: buildExistingThreadLookupMessage(params) })
-          : error,
-      ),
-    )
+    })
   }
 
   return { findById, getById, findAll, create, update, deleteById, findThreadByUniqueLookup, waitForExistingThread }

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

@@ -1,13 +1,16 @@
 import { THREAD } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import { AiGatewayModelsTag } from '../../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
 import { chatLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
+import { ERROR_TAGS } from '../../effect/errors'
 import type { HelperModelRuntime } from '../../runtime/helper-model'
 import { HelperModelTag } from '../../runtime/helper-model'
 import { deriveTitle, limitTitleWords, normalizeTitle } from '../../runtime/title-helpers'
 import {
-  createThreadTitleGeneratorAgent,
+  makeThreadTitleGeneratorAgentFactory,
   THREAD_TITLE_GENERATOR_PROMPT,
 } from '../../system-agents/title-generator.agent'
 import type { makeThreadService } from './thread.service'
@@ -15,7 +18,7 @@ import { ThreadServiceTag } from './thread.service'
 
 const THREAD_TITLE_TIMEOUT_MS = 30_000
 
-class ThreadTitleError extends Schema.TaggedErrorClass<ThreadTitleError>()('ThreadTitleError', {
+class ThreadTitleError extends Schema.TaggedErrorClass<ThreadTitleError>()(ERROR_TAGS.ThreadTitleError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
@@ -23,7 +26,9 @@ class ThreadTitleError extends Schema.TaggedErrorClass<ThreadTitleError>()('Thre
 export function makeThreadTitleService(
   threadService: ReturnType<typeof makeThreadService>,
   helperModelRuntime: HelperModelRuntime,
+  aiGatewayModels: AiGatewayModels,
 ) {
+  const createAgent = makeThreadTitleGeneratorAgentFactory(aiGatewayModels)
   return {
     generateAndPersistTitle(threadId: RecordIdRef, sourceText: string) {
       return Effect.gen(function* () {
@@ -31,7 +36,7 @@ export function makeThreadTitleService(
           try: () =>
             helperModelRuntime.generateHelperText({
               tag: 'thread-title',
-              createAgent: createThreadTitleGeneratorAgent,
+              createAgent,
               defaultSystemPrompt: THREAD_TITLE_GENERATOR_PROMPT,
               timeoutMs: THREAD_TITLE_TIMEOUT_MS,
               messages: [{ role: 'user', content: sourceText }],
@@ -69,6 +74,7 @@ export const ThreadTitleServiceLive = Layer.effect(
   Effect.gen(function* () {
     const threadService = yield* ThreadServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    return makeThreadTitleService(threadService, helperModelRuntime)
+    const aiGatewayModels = yield* AiGatewayModelsTag
+    return makeThreadTitleService(threadService, helperModelRuntime, aiGatewayModels)
   }),
 )