@lota-sdk/core 0.4.7 → 0.4.9

package/src/services/thread.service.ts

@@ -1,869 +0,0 @@
-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
-const THREAD_BOOTSTRAP_LOCK_TTL_MS = 15_000
-const THREAD_BOOTSTRAP_LOCK_REFRESH_INTERVAL_MS = 5_000
-const THREAD_BOOTSTRAP_LOCK_MAX_WAIT_MS = 5_000
-const THREAD_BOOTSTRAP_LOCK_RETRY_DELAY_MS = 100
-const THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS = 20
-const THREAD_UNIQUE_LOOKUP_RETRY_DELAY_MS = 100
-
-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 buildBootstrapThreadsLockKey(userId: RecordIdRef, orgId: RecordIdRef): string {
-  return `thread-bootstrap:${recordIdToString(ensureRecordId(userId, TABLES.USER), TABLES.USER)}:${recordIdToString(ensureRecordId(orgId, TABLES.ORGANIZATION), TABLES.ORGANIZATION)}`
-}
-
-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')
-}
-
-function requireExistingThread(
-  record: ThreadRecord | null,
-  params: {
-    type: 'default' | 'thread'
-    organizationId: RecordIdRef
-    userId: RecordIdRef
-    agentId?: string
-    threadType?: string
-  },
-): ThreadRecord {
-  if (record) {
-    return record
-  }
-
-  const scope = {
-    organizationId: recordIdToString(params.organizationId, TABLES.ORGANIZATION),
-    userId: recordIdToString(params.userId, TABLES.USER),
-    ...(params.agentId ? { agentId: params.agentId } : {}),
-    ...(params.threadType ? { threadType: params.threadType } : {}),
-  }
-  throw new Error(`Thread lookup failed after duplicate ${params.type} thread create: ${JSON.stringify(scope)}`)
-}
-
-type UniqueThreadLookupParams = Parameters<typeof requireExistingThread>[1]
-
-function haveSameMembers(left: string[], right: string[]): boolean {
-  return left.length === right.length && left.every((value, index) => value === right[index])
-}
-
-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 nameGenerated = input.title !== undefined && input.title !== THREAD.DEFAULT_TITLE
-
-    if (input.type === 'default') {
-      const agentId = input.agentId
-      if (!agentId) {
-        throw new Error('Default threads require agentId')
-      }
-      const { record } = await this.getOrCreateDefault(input.organizationId, input.userId, agentId)
-      return await this.toNormalizedThread(record)
-    }
-
-    if (input.type === 'thread') {
-      const threadType = input.threadType
-      if (!threadType) {
-        throw new Error('Thread threads require threadType')
-      }
-      const { record } = await this.getOrCreateThread(input.organizationId, input.userId, threadType, {
-        members: input.members ?? [...agentRoster],
-        title,
-        nameGenerated,
-      })
-      return await this.toNormalizedThread(record)
-    }
-
-    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,
-      isCompacting: false,
-      turnCount: 0,
-    })
-
-    return await this.toNormalizedThread(thread)
-  }
-
-  async getOrCreateDefault(
-    orgId: RecordIdRef,
-    userId: RecordIdRef,
-    agentId: string,
-    config?: { title?: string; nameGenerated?: boolean },
-  ): Promise<{ record: ThreadRecord; created: boolean }> {
-    const lookup = { type: 'default' as const, organizationId: orgId, userId, agentId }
-    const existing = await this.findThreadByUniqueLookup(lookup)
-    if (existing) {
-      return { record: await this.syncThreadConfig(existing, config), created: false }
-    }
-
-    try {
-      const record = await this.create({
-        type: 'default',
-        organizationId: orgId,
-        userId,
-        agentId,
-        members: [agentId],
-        title: config?.title ?? getAgentDisplayName(agentId),
-        status: 'active',
-        nameGenerated: config?.nameGenerated ?? false,
-        isCompacting: false,
-        turnCount: 0,
-      })
-      return { record, created: true }
-    } catch (e) {
-      if (isUniqueConstraintError(e)) {
-        return { record: await this.syncThreadConfig(await this.waitForExistingThread(lookup), config), created: false }
-      }
-      throw e
-    }
-  }
-
-  async getOrCreateThread(
-    orgId: RecordIdRef,
-    userId: RecordIdRef,
-    threadType: string,
-    config: { members: string[]; title: string; nameGenerated?: boolean },
-  ): Promise<{ record: ThreadRecord; created: boolean }> {
-    const lookup = { type: 'thread' as const, organizationId: orgId, userId, threadType }
-    const existing = await this.findThreadByUniqueLookup(lookup)
-    if (existing) {
-      return { record: await this.syncThreadConfig(existing, config), created: false }
-    }
-
-    try {
-      const record = await this.create({
-        type: 'thread',
-        organizationId: orgId,
-        userId,
-        threadType,
-        members: config.members,
-        title: config.title,
-        status: 'active',
-        nameGenerated: config.nameGenerated ?? false,
-        isCompacting: false,
-        turnCount: 0,
-      })
-      return { record, created: true }
-    } catch (e) {
-      if (isUniqueConstraintError(e)) {
-        return { record: await this.syncThreadConfig(await this.waitForExistingThread(lookup), config), created: false }
-      }
-      throw e
-    }
-  }
-
-  private async syncThreadConfig(
-    record: ThreadRecord,
-    config?: { title?: string; nameGenerated?: boolean; members?: string[] },
-  ): Promise<ThreadRecord> {
-    if (!config) {
-      return record
-    }
-
-    const updates: Partial<ThreadRecord> = {}
-
-    if (config.title !== undefined && record.title !== config.title) {
-      updates.title = config.title
-    }
-    if (config.nameGenerated !== undefined && record.nameGenerated !== config.nameGenerated) {
-      updates.nameGenerated = config.nameGenerated
-    }
-    if (config.members !== undefined && !haveSameMembers(record.members, config.members)) {
-      updates.members = config.members
-    }
-
-    if (Object.keys(updates).length === 0) {
-      return record
-    }
-
-    return await this.update(record.id, updates)
-  }
-
-  private async findThreadByUniqueLookup(params: UniqueThreadLookupParams): Promise<ThreadRecord | null> {
-    return await this.databaseService.findOne(
-      this.table,
-      {
-        type: params.type,
-        organizationId: params.organizationId,
-        userId: params.userId,
-        ...(params.agentId ? { agentId: params.agentId } : {}),
-        ...(params.threadType ? { threadType: params.threadType } : {}),
-      },
-      ThreadSchema,
-    )
-  }
-
-  private async waitForExistingThread(params: UniqueThreadLookupParams): Promise<ThreadRecord> {
-    for (let attempt = 0; attempt < THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS; attempt += 1) {
-      const record = await this.findThreadByUniqueLookup(params)
-      if (record) {
-        return record
-      }
-      if (attempt < THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS - 1) {
-        await Bun.sleep(THREAD_UNIQUE_LOOKUP_RETRY_DELAY_MS)
-      }
-    }
-
-    return requireExistingThread(null, params)
-  }
-
-  async ensureBootstrapThreads(
-    userId: RecordIdRef,
-    orgId: RecordIdRef,
-    options?: { onboardStatus?: string; userName?: string | null },
-  ): Promise<void> {
-    await withRedisLeaseLock(
-      {
-        redis: getRedisConnection(),
-        lockKey: buildBootstrapThreadsLockKey(userId, orgId),
-        lockTtlMs: THREAD_BOOTSTRAP_LOCK_TTL_MS,
-        refreshIntervalMs: THREAD_BOOTSTRAP_LOCK_REFRESH_INTERVAL_MS,
-        retryDelayMs: THREAD_BOOTSTRAP_LOCK_RETRY_DELAY_MS,
-        maxWaitMs: THREAD_BOOTSTRAP_LOCK_MAX_WAIT_MS,
-        label: 'thread bootstrap',
-        logger: serverLogger,
-      },
-      async (signal) => {
-        const throwIfAborted = () => {
-          if (signal.aborted) {
-            throw signal.reason instanceof Error ? signal.reason : new Error('Thread bootstrap lease was aborted.')
-          }
-        }
-
-        throwIfAborted()
-        const onboardStatus = options?.onboardStatus ?? 'completed'
-        const onboardingCompleted = onboardStatus === 'completed'
-        const bootstrapConfig = getThreadBootstrapConfig()
-
-        const existingThreads = await databaseService.findMany(
-          TABLES.THREAD,
-          { userId, organizationId: orgId },
-          ThreadSchema,
-        )
-        throwIfAborted()
-
-        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 creationTasks: Array<() => Promise<{ record: ThreadRecord; created: boolean }>> = []
-
-        for (const agentId of requiredDefaultAgents) {
-          if (defaultThreadsByAgent.has(agentId)) continue
-          creationTasks.push(async () => await this.getOrCreateDefault(orgId, userId, agentId))
-        }
-
-        if (onboardingCompleted && bootstrapConfig.ensureDefaultGroupOnCompleted && !hasGroupThread) {
-          creationTasks.push(
-            async () =>
-              await this.createThread({
-                userId,
-                organizationId: orgId,
-                type: 'group',
-                title: THREAD.DEFAULT_TITLE,
-              }).then(async (normalized) => ({
-                record: await this.getById(ensureRecordId(normalized.id, TABLES.THREAD)),
-                created: true,
-              })),
-          )
-        }
-
-        if (onboardingCompleted) {
-          for (const wsType of bootstrapConfig.threadTypesAfterOnboarding) {
-            if (threadThreadsByType.has(wsType)) continue
-            const profile = getCoreThreadProfile(wsType)
-            creationTasks.push(
-              async () =>
-                await this.getOrCreateThread(orgId, userId, wsType, {
-                  members: [...profile.members],
-                  title: profile.config.title,
-                }),
-            )
-          }
-        }
-
-        let createdResults: { record: ThreadRecord; created: boolean }[] = []
-        if (creationTasks.length > 0) {
-          for (const runCreation of creationTasks) {
-            throwIfAborted()
-            createdResults.push(await runCreation())
-            throwIfAborted()
-          }
-        }
-
-        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) {
-            throwIfAborted()
-            const ownerThreadRef = ensureRecordId(ownerThreadId, TABLES.THREAD)
-            await threadMessageService.ensureBootstrapWelcomeMessage({
-              threadId: ownerThreadRef,
-              agentId: onboardingWelcome.defaultAgentId,
-              text: onboardingWelcome.buildMessageText({ userName: options?.userName }),
-            })
-            throwIfAborted()
-          }
-        }
-      },
-    )
-  }
-
-  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 clearThread(threadId: RecordIdRef): Promise<void> {
-    const existing = await this.getById(threadId)
-    assertMutableThread(existing)
-    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
-    await databaseService.deleteWhere(TABLES.THREAD_MESSAGE, { threadId: threadRef })
-    await databaseService.query<unknown>(surql`
-      UPDATE ONLY ${threadRef}
-      SET turnCount = 0,
-          compactionSummary = NONE,
-          lastCompactedMessageId = NONE,
-          activeRunId = NONE,
-          activeStreamId = NONE,
-          isCompacting = false
-    `)
-  }
-
-  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()