@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -0,0 +1,199 @@
+import { THREAD } from '@lota-sdk/shared'
+import { Schema, Effect } from 'effect'
+import { BoundQuery } from 'surrealdb'
+
+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 { ThreadSchema } from './thread.types'
+import type { NormalizedThread, ThreadRecord } from './thread.types'
+
+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')
+}
+
+export function createThreadListingHelpers(deps: {
+  db: SurrealDBService
+  normalizeThreads(
+    threads: ThreadRecord[],
+    options?: { checkLease?: boolean },
+  ): Effect.Effect<NormalizedThread[], BadRequestError | ServiceError>
+}) {
+  class ThreadListingError extends Schema.TaggedErrorClass<ThreadListingError>()('ThreadListingError', {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  }) {}
+
+  const effectTryPromise = makeEffectTryPromiseWithMessage(
+    (message, cause) => new ThreadListingError({ message, cause }),
+  )
+
+  function listThreads(
+    userId: RecordIdRef,
+    orgId: RecordIdRef,
+    options: { type?: string; types?: string[]; take?: number; page?: number; includeArchived?: boolean },
+  ): Effect.Effect<{ threads: NormalizedThread[]; hasMore: boolean }, ThreadListingError> {
+    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 }
+      return Effect.gen(function* () {
+        const threads = yield* effectTryPromise(
+          () =>
+            deps.db.queryMany(
+              new BoundQuery(buildListThreadsQuery({ includeArchived, paginate: false, type }), vars),
+              ThreadSchema,
+            ),
+          'Failed to list threads.',
+        )
+        const normalizedThreads = yield* effectTryPromise(
+          () => deps.normalizeThreads(threads, { checkLease: false }),
+          'Failed to normalize listed threads.',
+        )
+        return { threads: normalizedThreads, 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
+    }
+
+    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 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.',
+      )
+      return { threads: normalizedThreads, hasMore }
+    })
+  }
+
+  function listOrganizationThreads(params: {
+    orgId: RecordIdRef
+    type?: string
+    agentId?: string
+    includeArchived?: boolean
+  }): Effect.Effect<NormalizedThread[], ThreadListingError> {
+    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"')
+    }
+
+    return Effect.gen(function* () {
+      const threads = yield* effectTryPromise(
+        () =>
+          deps.db.queryMany(
+            new BoundQuery(
+              `SELECT * FROM ${TABLES.THREAD}
+         WHERE ${whereClauses.join('\n           AND ')}
+         ORDER BY createdAt ASC, id ASC`,
+              variables,
+            ),
+            ThreadSchema,
+          ),
+        'Failed to list organization threads.',
+      )
+      return yield* effectTryPromise(
+        () => deps.normalizeThreads(threads, { checkLease: false }),
+        'Failed to normalize organization threads.',
+      )
+    })
+  }
+
+  function listRecentThreads({
+    userId,
+    orgId,
+    excludeThreadId,
+    limit,
+  }: {
+    userId: RecordIdRef
+    orgId: RecordIdRef
+    excludeThreadId?: RecordIdRef
+    limit: number
+  }): Effect.Effect<NormalizedThread[], ThreadListingError> {
+    let excludeCondition = ''
+    const vars: Record<string, unknown> = { userId, orgId, limit }
+
+    if (excludeThreadId) {
+      excludeCondition = 'AND id != $excludeThreadId'
+      vars.excludeThreadId = excludeThreadId
+    }
+
+    return Effect.gen(function* () {
+      const threads = yield* effectTryPromise(
+        () =>
+          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,
+          ),
+        'Failed to list recent threads.',
+      )
+      return yield* effectTryPromise(
+        () => deps.normalizeThreads(threads, { checkLease: false }),
+        'Failed to normalize recent threads.',
+      )
+    })
+  }
+
+  return { listThreads, listOrganizationThreads, listRecentThreads }
+}

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

@@ -0,0 +1,130 @@
+import type { Context } from 'effect'
+import { Schema, Effect } from 'effect'
+
+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 {
+  appendToMemoryBlock,
+  compactMemoryBlockEntries,
+  formatPersistedMemoryBlockForPrompt,
+  MemoryBlockCompactError,
+  parseMemoryBlock,
+  serializeMemoryBlock,
+} from '../../runtime/memory/memory-block'
+import type { BackgroundWorkService } 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'
+import type { ThreadRecord } from './thread.types'
+
+type ContextCompactionServiceLike = Pick<ReturnType<typeof makeContextCompactionService>, 'compactMemoryBlock'>
+
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
+
+class ThreadMemoryBlockError extends Schema.TaggedErrorClass<ThreadMemoryBlockError>()('ThreadMemoryBlockError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+const tryThreadMemoryBlockEffect = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ThreadMemoryBlockError({ message, cause }),
+)
+
+export function formatMemoryBlockForPrompt(thread: Pick<ThreadRecord, 'memoryBlock' | 'memoryBlockSummary'>): string {
+  return formatPersistedMemoryBlockForPrompt({
+    summary: thread.memoryBlockSummary,
+    entries: parseMemoryBlock(thread.memoryBlock),
+  })
+}
+
+export function createThreadMemoryBlockHelpers(deps: {
+  threadStore: ThreadRecordStore
+  contextCompactionService: ContextCompactionServiceLike
+  background: BackgroundWorker
+}) {
+  function appendMemoryBlock(threadId: RecordIdRef, entry: string): Effect.Effect<string, ThreadMemoryBlockError> {
+    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 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)
+
+      yield* tryThreadMemoryBlockEffect(
+        () => deps.threadStore.update(threadRef, { memoryBlock: serialized }),
+        `Failed to persist memory block for thread ${threadIdString}`,
+      )
+
+      if (updatedEntries.length >= MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES) {
+        yield* deps.background.run(
+          compactMemoryBlock(threadRef).pipe(
+            Effect.catch((error: unknown) =>
+              Effect.sync(() => {
+                serverLogger.warn`Memory block compaction failed for ${threadIdString}: ${error}`
+              }),
+            ),
+          ),
+          'thread-memory-block.compactMemoryBlock',
+        )
+      }
+
+      return formatMemoryBlockForPrompt({ memoryBlock: serialized, memoryBlockSummary: thread.memoryBlockSummary })
+    })
+  }
+
+  function compactMemoryBlock(threadId: RecordIdRef): Effect.Effect<boolean, ThreadMemoryBlockError> {
+    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}`,
+      )
+
+      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}`,
+      )
+
+      return true
+    })
+  }
+
+  return { appendMemoryBlock, compactMemoryBlock }
+}