@lota-sdk/core 0.2.2 → 0.3.0

package/src/services/thread.service.ts

@@ -0,0 +1,707 @@
+import { THREAD, sdkThreadStatusSchema } from '@lota-sdk/shared'
+import { BoundQuery, RecordId, StringRecordId, surql } from 'surrealdb'
+
+import { agentDisplayNames, agentRoster, getCoreThreadProfile, isAgentName } from '../config/agent-defaults'
+import { serverLogger } from '../config/logger'
+import { getThreadBootstrapConfig } from '../config/thread-defaults'
+import { BaseService } from '../db/base.service'
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import type { RecordIdInput, RecordIdRef } from '../db/record-id'
+import { databaseService } from '../db/service'
+import type { DatabaseTable } from '../db/tables'
+import { TABLES } from '../db/tables'
+import { getRedisConnection, withRedisLeaseLock } from '../redis'
+import {
+  appendToMemoryBlock,
+  compactMemoryBlockEntries,
+  formatPersistedMemoryBlockForPrompt,
+  parseMemoryBlock,
+  serializeMemoryBlock,
+} from '../runtime/memory-block'
+import { toIsoDateTimeString } from '../utils/date-time'
+import { chatRunRegistry } from './chat-run-registry.service'
+import { contextCompactionService } from './context-compaction.service'
+import { MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES, MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES } from './thread-constants'
+import { threadMessageService } from './thread-message.service'
+import { NormalizedThreadSchema, PublicThreadSchema, ThreadSchema } from './thread.types'
+import type { NormalizedThread, PublicThread, ThreadRecord } from './thread.types'
+
+const THREAD_ACTIVE_RUN_LOCK_TTL_MS = 90_000
+const THREAD_ACTIVE_RUN_LOCK_MAX_WAIT_MS = 750
+const THREAD_ACTIVE_RUN_LOCK_RETRY_DELAY_MS = 75
+
+function isRecordIdInput(value: unknown): value is RecordIdInput {
+  if (typeof value === 'string' || value instanceof RecordId || value instanceof StringRecordId) {
+    return true
+  }
+
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const record = value as { tb?: unknown; id?: unknown }
+  return typeof record.tb === 'string' && record.id !== undefined
+}
+
+function getAgentDisplayName(agentId: string): string {
+  return agentDisplayNames[agentId] ?? agentId
+}
+
+function buildActiveRunLockKey(threadId: RecordIdRef): string {
+  return `thread-active-run:${recordIdToString(ensureRecordId(threadId, TABLES.THREAD), TABLES.THREAD)}`
+}
+
+function buildListThreadsQuery(options: {
+  includeArchived: boolean
+  paginate: boolean
+  type?: string
+  types?: string[]
+}): string {
+  const clauses = [`SELECT * FROM ${TABLES.THREAD}`, 'WHERE userId = $userId', '  AND organizationId = $orgId']
+
+  if (options.types) {
+    clauses.push('  AND type IN $types')
+  } else if (options.type) {
+    clauses.push('  AND type = $type')
+  }
+
+  if (!options.includeArchived) {
+    clauses.push('  AND status = "active"')
+  }
+  clauses.push('ORDER BY updatedAt DESC')
+  if (options.paginate) {
+    clauses.push('LIMIT $limit START $offset')
+  }
+  return clauses.join('\n')
+}
+
+function normalizeActiveTurnValue(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null
+  }
+
+  const normalized = value.trim()
+  return normalized.length > 0 ? normalized : null
+}
+
+function assertMutableThread(thread: ThreadRecord): void {
+  if (thread.type === 'default') throw new Error('Default threads cannot be modified')
+  if (thread.type === 'thread') throw new Error('Thread threads cannot be modified')
+}
+
+function isUniqueConstraintError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false
+  return error.message.includes('already contains')
+}
+
+export class ActiveThreadRunConflictError extends Error {
+  constructor() {
+    super('A chat run is already active.')
+    this.name = 'ActiveThreadRunConflictError'
+  }
+}
+
+class ThreadService extends BaseService<typeof ThreadSchema> {
+  constructor() {
+    super(TABLES.THREAD, ThreadSchema)
+  }
+
+  async createThread(input: {
+    userId: RecordIdRef
+    organizationId: RecordIdRef
+    type: string
+    agentId?: string
+    threadType?: string
+    members?: string[]
+    title?: string
+  }): Promise<NormalizedThread> {
+    switch (input.type) {
+      case 'default':
+        if (!input.agentId) throw new Error('Default threads require agentId')
+        if (input.threadType) throw new Error('Default threads cannot have threadType')
+        break
+      case 'topic':
+        if (!input.agentId) throw new Error('Topic threads require agentId')
+        if (input.threadType) throw new Error('Topic threads cannot have threadType')
+        break
+      case 'thread':
+        if (!input.threadType) throw new Error('Thread threads require threadType')
+        if (input.agentId) throw new Error('Thread threads cannot have agentId')
+        break
+      case 'group':
+        if (input.agentId) throw new Error('Group threads cannot have agentId')
+        if (input.threadType) throw new Error('Group threads cannot have threadType')
+        break
+    }
+
+    const title = input.title ?? THREAD.DEFAULT_TITLE
+    const thread = await this.create({
+      userId: input.userId,
+      organizationId: input.organizationId,
+      type: input.type,
+      agentId: input.agentId,
+      threadType: input.threadType,
+      members: input.members ?? [...agentRoster],
+      title,
+      status: 'active',
+      nameGenerated: input.title !== undefined && input.title !== THREAD.DEFAULT_TITLE,
+      isCompacting: false,
+      turnCount: 0,
+    })
+
+    return await this.toNormalizedThread(thread)
+  }
+
+  async getOrCreateDefault(
+    orgId: RecordIdRef,
+    userId: RecordIdRef,
+    agentId: string,
+  ): Promise<{ record: ThreadRecord; created: boolean }> {
+    const existing = await this.databaseService.findOne(
+      this.table,
+      { type: 'default', organizationId: orgId, userId, agentId },
+      ThreadSchema,
+    )
+    if (existing) return { record: existing, created: false }
+
+    try {
+      const record = await this.create({
+        type: 'default',
+        organizationId: orgId,
+        userId,
+        agentId,
+        members: [agentId],
+        title: getAgentDisplayName(agentId),
+        status: 'active',
+        nameGenerated: false,
+        isCompacting: false,
+        turnCount: 0,
+      })
+      return { record, created: true }
+    } catch (e) {
+      if (isUniqueConstraintError(e)) {
+        const retried = await this.databaseService.findOne(
+          this.table,
+          { type: 'default', organizationId: orgId, userId, agentId },
+          ThreadSchema,
+        )
+        return { record: retried!, created: false }
+      }
+      throw e
+    }
+  }
+
+  async getOrCreateThread(
+    orgId: RecordIdRef,
+    userId: RecordIdRef,
+    threadType: string,
+    config: { members: string[]; title: string },
+  ): Promise<{ record: ThreadRecord; created: boolean }> {
+    const existing = await this.databaseService.findOne(
+      this.table,
+      { type: 'thread', organizationId: orgId, userId, threadType },
+      ThreadSchema,
+    )
+    if (existing) return { record: existing, created: false }
+
+    try {
+      const record = await this.create({
+        type: 'thread',
+        organizationId: orgId,
+        userId,
+        threadType,
+        members: config.members,
+        title: config.title,
+        status: 'active',
+        nameGenerated: false,
+        isCompacting: false,
+        turnCount: 0,
+      })
+      return { record, created: true }
+    } catch (e) {
+      if (isUniqueConstraintError(e)) {
+        const retried = await this.databaseService.findOne(
+          this.table,
+          { type: 'thread', organizationId: orgId, userId, threadType },
+          ThreadSchema,
+        )
+        return { record: retried!, created: false }
+      }
+      throw e
+    }
+  }
+
+  async ensureBootstrapThreads(
+    userId: RecordIdRef,
+    orgId: RecordIdRef,
+    options?: { onboardStatus?: string; userName?: string | null },
+  ): Promise<void> {
+    const onboardStatus = options?.onboardStatus ?? 'completed'
+    const onboardingCompleted = onboardStatus === 'completed'
+    const bootstrapConfig = getThreadBootstrapConfig()
+
+    const existingThreads = await databaseService.findMany(
+      TABLES.THREAD,
+      { userId, organizationId: orgId },
+      ThreadSchema,
+    )
+
+    const hasGroupThread = existingThreads.some((t) => t.type === 'group')
+    const defaultThreadsByAgent = new Map<string, ThreadRecord>()
+    const threadThreadsByType = new Map<string, ThreadRecord>()
+
+    for (const thread of existingThreads) {
+      if (thread.type === 'default' && thread.agentId) {
+        defaultThreadsByAgent.set(thread.agentId, thread)
+      }
+      if (thread.type === 'thread' && typeof thread.threadType === 'string') {
+        threadThreadsByType.set(thread.threadType, thread)
+      }
+    }
+
+    const requiredDefaultAgents = onboardingCompleted
+      ? bootstrapConfig.completedDefaultAgents
+      : bootstrapConfig.onboardingDefaultAgents
+
+    const creations: Promise<{ record: ThreadRecord; created: boolean }>[] = []
+
+    for (const agentId of requiredDefaultAgents) {
+      if (defaultThreadsByAgent.has(agentId)) continue
+      creations.push(this.getOrCreateDefault(orgId, userId, agentId))
+    }
+
+    if (onboardingCompleted && bootstrapConfig.ensureDefaultGroupOnCompleted && !hasGroupThread) {
+      creations.push(
+        this.createThread({ userId, organizationId: orgId, type: 'group', title: THREAD.DEFAULT_TITLE }).then(
+          (normalized) => ({ record: normalized as unknown as ThreadRecord, created: true }),
+        ),
+      )
+    }
+
+    if (onboardingCompleted) {
+      for (const wsType of bootstrapConfig.threadTypesAfterOnboarding) {
+        if (threadThreadsByType.has(wsType)) continue
+        const profile = getCoreThreadProfile(wsType)
+        creations.push(
+          this.getOrCreateThread(orgId, userId, wsType, { members: [...profile.members], title: profile.config.title }),
+        )
+      }
+    }
+
+    let createdResults: { record: ThreadRecord; created: boolean }[] = []
+    if (creations.length > 0) {
+      createdResults = await Promise.all(creations)
+    }
+
+    const onboardingWelcome = bootstrapConfig.onboardingWelcome
+    if (!onboardingCompleted && onboardingWelcome) {
+      const createdOwnerThread = createdResults.find(
+        (r) => r.created && r.record.type === 'default' && r.record.agentId === onboardingWelcome.defaultAgentId,
+      )
+      const existingOwnerThread = defaultThreadsByAgent.get(onboardingWelcome.defaultAgentId)
+
+      const ownerThreadId = createdOwnerThread?.record.id ?? existingOwnerThread?.id
+
+      if (ownerThreadId) {
+        const ownerThreadRef = ensureRecordId(ownerThreadId, TABLES.THREAD)
+        await threadMessageService.ensureBootstrapWelcomeMessage({
+          threadId: ownerThreadRef,
+          agentId: onboardingWelcome.defaultAgentId,
+          text: onboardingWelcome.buildMessageText({ userName: options?.userName }),
+        })
+      }
+    }
+  }
+
+  async listThreads(
+    userId: RecordIdRef,
+    orgId: RecordIdRef,
+    options: { type?: string; types?: string[]; take?: number; page?: number; includeArchived?: boolean },
+  ): Promise<{ threads: NormalizedThread[]; hasMore: boolean }> {
+    const includeArchived = options.includeArchived ?? false
+    const type = options.type
+    const types = options.types
+
+    if (type === 'default' || type === 'thread') {
+      const vars: Record<string, unknown> = { userId, orgId, type }
+      const threads = await databaseService.queryMany<typeof ThreadSchema>(
+        new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: false, type }), vars),
+        ThreadSchema,
+      )
+      return { threads: await this.toNormalizedThreads(threads, { checkLease: false }), hasMore: false }
+    }
+
+    const take = options.take ?? THREAD.DEFAULT_PAGE_LIMIT
+    const page = options.page ?? 1
+    const vars: Record<string, unknown> = { userId, orgId, limit: take + 1, offset: (page - 1) * take }
+
+    if (types) {
+      vars.types = types
+    } else if (type) {
+      vars.type = type
+    }
+
+    const threads = await databaseService.queryMany<typeof ThreadSchema>(
+      new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: true, type, types }), vars),
+      ThreadSchema,
+    )
+
+    const hasMore = threads.length > take
+    const sliced = hasMore ? threads.slice(0, take) : threads
+
+    return { threads: await this.toNormalizedThreads(sliced, { checkLease: false }), hasMore }
+  }
+
+  async listOrganizationThreads(params: {
+    orgId: RecordIdRef
+    type?: string
+    agentId?: string
+    includeArchived?: boolean
+  }): Promise<NormalizedThread[]> {
+    const whereClauses = ['organizationId = $orgId']
+    const variables: Record<string, unknown> = { orgId: params.orgId }
+
+    if (params.type) {
+      whereClauses.push('type = $type')
+      variables.type = params.type
+    }
+
+    if (params.agentId) {
+      whereClauses.push('agentId = $agentId')
+      variables.agentId = params.agentId
+    }
+
+    if (params.includeArchived !== true) {
+      whereClauses.push('status = "active"')
+    }
+
+    const threads = await databaseService.queryMany<typeof ThreadSchema>(
+      new BoundQuery(
+        `SELECT * FROM ${TABLES.THREAD}
+         WHERE ${whereClauses.join('\n           AND ')}
+         ORDER BY createdAt ASC, id ASC`,
+        variables,
+      ),
+      ThreadSchema,
+    )
+
+    return await this.toNormalizedThreads(threads, { checkLease: false })
+  }
+
+  async getThread(threadId: RecordIdRef): Promise<NormalizedThread> {
+    const thread = await this.getById(threadId)
+    return await this.toNormalizedThread(thread)
+  }
+
+  async updateTitle(threadId: RecordIdRef, title: string): Promise<NormalizedThread> {
+    const existing = await this.getById(threadId)
+    assertMutableThread(existing)
+    const thread = await this.update(threadId, { title, nameGenerated: true })
+    return await this.toNormalizedThread(thread)
+  }
+
+  async updateStatus(threadId: RecordIdRef, status: string): Promise<NormalizedThread> {
+    const validStatus = sdkThreadStatusSchema.parse(status)
+    const existing = await this.getById(threadId)
+    assertMutableThread(existing)
+    const thread = await this.update(threadId, { status: validStatus })
+    return await this.toNormalizedThread(thread)
+  }
+
+  async setActiveTurn(threadId: RecordIdRef, runId: string, streamId?: string | null): Promise<void> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    if (streamId === null || streamId === undefined) {
+      await databaseService.query<unknown>(surql`
+        UPDATE ONLY ${threadRef}
+        SET activeRunId = ${runId},
+            activeStreamId = NONE
+      `)
+      return
+    }
+
+    await databaseService.query<unknown>(surql`
+      UPDATE ONLY ${threadRef}
+      SET activeRunId = ${runId},
+          activeStreamId = ${streamId}
+    `)
+  }
+
+  async getActiveTurn(threadId: RecordIdRef): Promise<{ runId: string | null; streamId: string | null }> {
+    const thread = await this.getById(threadId)
+    return {
+      runId: normalizeActiveTurnValue(thread.activeRunId),
+      streamId: normalizeActiveTurnValue(thread.activeStreamId),
+    }
+  }
+
+  async getActiveRunId(threadId: RecordIdRef): Promise<string | null> {
+    const { runId } = await this.getActiveTurn(threadId)
+    return runId
+  }
+
+  async hasActiveRunLease(threadId: RecordIdRef): Promise<boolean> {
+    const count = await getRedisConnection().exists(buildActiveRunLockKey(threadId))
+    return count > 0
+  }
+
+  async withActiveRunLease<T>(threadId: RecordIdRef, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+    try {
+      return await withRedisLeaseLock(
+        {
+          redis: getRedisConnection(),
+          lockKey: buildActiveRunLockKey(threadId),
+          lockTtlMs: THREAD_ACTIVE_RUN_LOCK_TTL_MS,
+          retryDelayMs: THREAD_ACTIVE_RUN_LOCK_RETRY_DELAY_MS,
+          maxWaitMs: THREAD_ACTIVE_RUN_LOCK_MAX_WAIT_MS,
+          label: 'thread active run',
+          logger: serverLogger,
+        },
+        fn,
+      )
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith('Timed out waiting for thread active run')) {
+        throw new ActiveThreadRunConflictError()
+      }
+      throw error
+    }
+  }
+
+  async getActiveStreamId(threadId: RecordIdRef): Promise<string | null> {
+    const { streamId } = await this.getActiveTurn(threadId)
+    return streamId
+  }
+
+  async clearActiveTurn(threadId: RecordIdRef, params: { runId: string; streamId?: string | null }): Promise<void> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const currentStreamId = params.streamId ?? null
+    if (currentStreamId === null) {
+      await databaseService.query(
+        surql`UPDATE ONLY ${threadRef} SET activeRunId = NONE, activeStreamId = NONE WHERE activeRunId = ${params.runId}`,
+      )
+      return
+    }
+
+    await databaseService.query(surql`
+      UPDATE ONLY ${threadRef}
+      SET activeRunId = NONE,
+          activeStreamId = NONE
+      WHERE activeRunId = ${params.runId} AND activeStreamId = ${currentStreamId}
+    `)
+  }
+
+  async clearStaleActiveRunIfMissingFromRegistry(threadId: RecordIdRef): Promise<boolean> {
+    const { runId: activeRunId, streamId: activeStreamId } = await this.getActiveTurn(threadId)
+    if (!activeRunId || (await this.hasActiveRunLease(threadId))) {
+      return false
+    }
+
+    await this.clearActiveTurn(threadId, { runId: activeRunId, streamId: activeStreamId })
+
+    serverLogger.warn`Cleared stale thread run after lease expired: thread=${recordIdToString(ensureRecordId(threadId, TABLES.THREAD), TABLES.THREAD)} run=${activeRunId}`
+    return true
+  }
+
+  async stopActiveRun(threadId: RecordIdRef): Promise<boolean> {
+    const { runId: activeRunId } = await this.getActiveTurn(threadId)
+    if (!activeRunId) return false
+
+    const stopped = chatRunRegistry.stop(activeRunId, new DOMException('Run stopped by user.', 'AbortError'))
+    if (stopped) {
+      return true
+    }
+
+    await this.clearStaleActiveRunIfMissingFromRegistry(threadId)
+    return false
+  }
+
+  async setCompacting(threadId: RecordIdRef, value: boolean): Promise<void> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    await databaseService.query<unknown>(surql`
+      UPDATE ONLY ${threadRef}
+      SET isCompacting = ${value}
+    `)
+  }
+
+  async appendMemoryBlock(threadId: RecordIdRef, entry: string): Promise<string> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const thread = await this.getById(threadRef)
+    const entries = parseMemoryBlock(thread.memoryBlock)
+
+    const labelMatch = entry.match(/^(\w+):\s*/i)
+    const role = labelMatch ? labelMatch[1].toLowerCase() : 'system'
+    const content = labelMatch ? entry.slice(labelMatch[0].length).trim() : entry.trim()
+
+    const updatedEntries = appendToMemoryBlock(entries, role, content)
+    const serialized = serializeMemoryBlock(updatedEntries)
+
+    await this.update(threadRef, { memoryBlock: serialized })
+
+    if (updatedEntries.length >= MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES) {
+      void this.compactMemoryBlock(threadRef).catch((err: unknown) => {
+        serverLogger.warn`Memory block compaction failed for ${threadRef}: ${err}`
+      })
+    }
+
+    return this.formatMemoryBlockForPrompt({ memoryBlock: serialized, memoryBlockSummary: thread.memoryBlockSummary })
+  }
+
+  async compactMemoryBlock(threadId: RecordIdRef): Promise<boolean> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const thread = await this.getById(threadRef)
+    const result = await compactMemoryBlockEntries({
+      previousSummary: thread.memoryBlockSummary,
+      entries: parseMemoryBlock(thread.memoryBlock),
+      triggerEntries: MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES,
+      chunkEntries: MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES,
+      compact: (params) => contextCompactionService.compactMemoryBlock(params),
+    })
+
+    if (!result.compacted) return false
+
+    await this.update(threadRef, {
+      memoryBlockSummary: result.summary || '',
+      memoryBlock: serializeMemoryBlock(result.entries),
+    })
+
+    return true
+  }
+
+  async deleteThread(threadId: RecordIdRef): Promise<void> {
+    const existing = await this.getById(threadId)
+    assertMutableThread(existing)
+    await this.delete(threadId)
+  }
+
+  async listRecentThreads({
+    userId,
+    orgId,
+    excludeThreadId,
+    limit,
+  }: {
+    userId: RecordIdRef
+    orgId: RecordIdRef
+    excludeThreadId?: RecordIdRef
+    limit: number
+  }): Promise<NormalizedThread[]> {
+    let excludeCondition = ''
+    const vars: Record<string, unknown> = { userId, orgId, limit }
+
+    if (excludeThreadId) {
+      excludeCondition = 'AND id != $excludeThreadId'
+      vars.excludeThreadId = excludeThreadId
+    }
+
+    const threads = await databaseService.queryMany<typeof ThreadSchema>(
+      new BoundQuery(
+        `SELECT * FROM ${TABLES.THREAD}
+	       WHERE userId = $userId
+	         AND organizationId = $orgId
+	         ${excludeCondition}
+	         AND status != "archived"
+	       ORDER BY updatedAt DESC
+	       LIMIT $limit`,
+        vars,
+      ),
+      ThreadSchema,
+    )
+
+    return await this.toNormalizedThreads(threads, { checkLease: false })
+  }
+
+  private normalizeRecordIdString(id: unknown, table: DatabaseTable): string {
+    if (!isRecordIdInput(id)) {
+      throw new Error(`Invalid record id for table ${table}`)
+    }
+
+    return recordIdToString(id, table)
+  }
+
+  formatMemoryBlockForPrompt(thread: Pick<ThreadRecord, 'memoryBlock' | 'memoryBlockSummary'>): string {
+    return formatPersistedMemoryBlockForPrompt({
+      summary: thread.memoryBlockSummary,
+      entries: parseMemoryBlock(thread.memoryBlock),
+    })
+  }
+
+  private getDefaultTitle(thread: Pick<ThreadRecord, 'type' | 'threadType'>): string {
+    if (thread.type === 'thread' && typeof thread.threadType === 'string') {
+      return getCoreThreadProfile(thread.threadType).config.title
+    }
+
+    return THREAD.DEFAULT_TITLE
+  }
+
+  private async computeIsRunning(
+    thread: Pick<ThreadRecord, 'id' | 'activeRunId'>,
+    options: { checkLease: boolean },
+  ): Promise<boolean> {
+    const activeRunId =
+      typeof thread.activeRunId === 'string' && thread.activeRunId.trim().length > 0 ? thread.activeRunId : null
+
+    if (activeRunId === null) {
+      return false
+    }
+
+    if (chatRunRegistry.has(activeRunId)) {
+      return true
+    }
+
+    if (!options.checkLease) {
+      return true
+    }
+
+    return await this.hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD))
+  }
+
+  private async toNormalizedThread(
+    thread: ThreadRecord,
+    options: { checkLease?: boolean } = {},
+  ): Promise<NormalizedThread> {
+    const isRunning = await this.computeIsRunning(thread, { checkLease: options.checkLease ?? true })
+    const isCompacting = thread.isCompacting === true
+    const type = thread.type
+    const threadType = type === 'thread' && typeof thread.threadType === 'string' ? thread.threadType : undefined
+    const status = thread.status
+    return NormalizedThreadSchema.parse({
+      id: this.normalizeRecordIdString(thread.id, TABLES.THREAD),
+      userId: this.normalizeRecordIdString(thread.userId, TABLES.USER),
+      organizationId: this.normalizeRecordIdString(thread.organizationId, TABLES.ORGANIZATION),
+      type,
+      ...(threadType ? { threadType } : {}),
+      nameGenerated: thread.nameGenerated,
+      isRunning,
+      isCompacting,
+      ...(isAgentName(thread.agentId) ? { agentId: thread.agentId } : {}),
+      title: thread.title ?? this.getDefaultTitle(thread),
+      status,
+      memoryBlock: this.formatMemoryBlockForPrompt(thread),
+      members: thread.members ?? [],
+      createdAt: toIsoDateTimeString(thread.createdAt),
+      updatedAt: toIsoDateTimeString(thread.updatedAt),
+    })
+  }
+
+  private async toNormalizedThreads(
+    threads: ThreadRecord[],
+    options: { checkLease?: boolean } = {},
+  ): Promise<NormalizedThread[]> {
+    return await Promise.all(threads.map(async (thread) => await this.toNormalizedThread(thread, options)))
+  }
+
+  toPublicThread(thread: NormalizedThread): PublicThread {
+    const { organizationId: _organizationId, userId: _userId, memoryBlock: _memoryBlock, ...publicThread } = thread
+    return PublicThreadSchema.parse(publicThread)
+  }
+
+  async incrementTurnCount(threadId: RecordIdRef): Promise<number> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const result = await databaseService.query<{ turnCount: number }>(surql`
+      UPDATE ONLY ${threadRef}
+      SET turnCount += 1
+      RETURN turnCount
+    `)
+    return result[0].turnCount
+  }
+}
+
+export const threadService = new ThreadService()