@lota-sdk/core 0.4.7 → 0.4.9

package/src/services/plan-workspace.service.ts

@@ -1,83 +0,0 @@
-import { z } from 'zod'
-
-import { getRedisConnection } from '../redis'
-
-const PlanWorkspaceEntrySchema = z.object({
-  value: z.unknown(),
-  version: z.number(),
-  writeSequence: z.number(),
-  nodeId: z.string(),
-  timestamp: z.number(),
-})
-
-export type PlanWorkspaceEntry = z.infer<typeof PlanWorkspaceEntrySchema>
-
-class PlanWorkspaceService {
-  private keyPrefix = 'plan-workspace:'
-
-  async write(params: {
-    runId: string
-    nodeId: string
-    key: string
-    value: unknown
-    version: number
-    checkpointSequence: number
-  }): Promise<void> {
-    const redis = getRedisConnection()
-    const hashKey = `${this.keyPrefix}${params.runId}`
-    const fieldKey = `${params.nodeId}:${params.key}`
-    const entry: PlanWorkspaceEntry = {
-      value: params.value,
-      version: params.version,
-      writeSequence: params.checkpointSequence,
-      nodeId: params.nodeId,
-      timestamp: Date.now(),
-    }
-    await redis.hset(hashKey, fieldKey, JSON.stringify(entry))
-  }
-
-  async snapshotRead(params: {
-    runId: string
-    readerNodeId: string
-    snapshotSequence?: number
-  }): Promise<Record<string, PlanWorkspaceEntry>> {
-    const redis = getRedisConnection()
-    const hashKey = `${this.keyPrefix}${params.runId}`
-    const nodePrefix = `${params.readerNodeId}:`
-    const all = await redis.hgetall(hashKey)
-    const result: Record<string, PlanWorkspaceEntry> = {}
-    for (const [fieldKey, raw] of Object.entries(all)) {
-      if (!fieldKey.startsWith(nodePrefix)) continue
-      const entry = PlanWorkspaceEntrySchema.parse(JSON.parse(raw))
-      if (params.snapshotSequence !== undefined && entry.writeSequence > params.snapshotSequence) {
-        continue
-      }
-      result[fieldKey] = entry
-    }
-    return result
-  }
-
-  async currentRead(params: { runId: string; key?: string }): Promise<Record<string, PlanWorkspaceEntry>> {
-    const redis = getRedisConnection()
-    const hashKey = `${this.keyPrefix}${params.runId}`
-    if (params.key) {
-      // Support both raw field keys (e.g. 'nodeId:key') and plain keys
-      const raw = await redis.hget(hashKey, params.key)
-      if (!raw) return {}
-      return { [params.key]: PlanWorkspaceEntrySchema.parse(JSON.parse(raw)) }
-    }
-    const all = await redis.hgetall(hashKey)
-    const result: Record<string, PlanWorkspaceEntry> = {}
-    for (const [k, v] of Object.entries(all)) {
-      result[k] = PlanWorkspaceEntrySchema.parse(JSON.parse(v))
-    }
-    return result
-  }
-
-  async cleanup(runId: string): Promise<void> {
-    const redis = getRedisConnection()
-    await redis.del(`${this.keyPrefix}${runId}`)
-  }
-}
-
-export const planWorkspaceService = new PlanWorkspaceService()

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

@@ -1,275 +0,0 @@
-import { parseRowMetadata, recordIdSchema, requireTimestamp, withCreatedAtMetadata } from '@lota-sdk/shared'
-import type { ChatMessage } from '@lota-sdk/shared'
-import { RecordId, surql } from 'surrealdb'
-import { z } from 'zod'
-
-import { agentDisplayNames } from '../config/agent-defaults'
-import { CursorRowSchema, listMessageHistoryPage } from '../db/cursor-pagination'
-import type { CursorPaginationConfig, MessageHistoryPage } from '../db/cursor-pagination'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import type { RecordIdRef } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-import { ThreadMessageRowSchema } from '../db/thread-message-row'
-import type { ThreadMessageRow } from '../db/thread-message-row'
-
-const ThreadMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
-
-function toMessageId(value: string | RecordIdRef): string {
-  return recordIdToString(value, TABLES.THREAD_MESSAGE)
-}
-
-/**
- * Builds a collision-free row id by hashing the thread + message id pair.
- * Previous implementation replaced non-alphanumeric chars with '_', which was
- * lossy (e.g. "msg:foo" and "msg_foo" mapped to the same row id).
- * Now uses a 32-char SHA-256 hex prefix -- short enough for ergonomic ids,
- * long enough (128 bits) to make collisions negligible.
- */
-function toThreadMessageRowId(threadId: RecordIdRef, messageId: string): RecordId {
-  const threadStr = recordIdToString(threadId, TABLES.THREAD)
-  const digest = new Bun.CryptoHasher('sha256').update(`${threadStr}\0${messageId}`).digest('hex').slice(0, 32)
-  return new RecordId(TABLES.THREAD_MESSAGE, digest)
-}
-
-function toThreadRef(threadId: RecordIdRef): RecordId {
-  return ensureRecordId(threadId, TABLES.THREAD)
-}
-
-function toChatMessage(row: ThreadMessageRow): ChatMessage {
-  const rowCreatedAt = requireTimestamp(row.createdAt)
-  const metadata = withCreatedAtMetadata(parseRowMetadata(row.metadata), rowCreatedAt)
-
-  return { id: row.messageId, role: row.role, parts: row.parts as ChatMessage['parts'], metadata }
-}
-
-const threadPaginationConfig: CursorPaginationConfig = {
-  table: TABLES.THREAD_MESSAGE,
-  parentFilterField: 'threadId',
-  toRowId: toThreadMessageRowId,
-  parseRow: (row: unknown) => ThreadMessageRowSchema.parse(row),
-  toMessage: (row: unknown) => toChatMessage(ThreadMessageRowSchema.parse(row)),
-  queryLatest: (parentId, limit) => surql`
-    SELECT * FROM threadMessage
-    WHERE threadId = ${parentId}
-    ORDER BY createdAt DESC, id DESC
-    LIMIT ${limit}
-  `,
-  queryBefore: (parentId, cursorCreatedAt, cursorId, limit) => surql`
-    SELECT * FROM threadMessage
-    WHERE threadId = ${parentId}
-      AND (
-        createdAt < ${cursorCreatedAt}
-        OR (createdAt = ${cursorCreatedAt} AND id < ${cursorId})
-      )
-    ORDER BY createdAt DESC, id DESC
-    LIMIT ${limit}
-  `,
-}
-
-class ThreadMessageService {
-  async upsertMessages(params: { threadId: RecordIdRef; messages: ChatMessage[] }): Promise<void> {
-    const threadId = toThreadRef(params.threadId)
-
-    const upsertPromises = params.messages.map(async (message) => {
-      const messageId = message.id.trim()
-      if (!messageId) return
-
-      const role = message.role
-      const parts = Array.isArray(message.parts)
-        ? message.parts.map((part) => structuredClone(part) as Record<string, unknown>)
-        : []
-      if (parts.length === 0) {
-        if (role === 'assistant') return
-        throw new Error(`Refusing to persist thread message "${messageId}" with empty parts`)
-      }
-      const rowId = toThreadMessageRowId(threadId, messageId)
-      const existingRow = await databaseService.findOne(
-        TABLES.THREAD_MESSAGE,
-        { threadId, messageId },
-        ThreadMessageExistingRowSchema,
-      )
-      const persistedCreatedAt =
-        existingRow === null ? requireTimestamp(message.metadata?.createdAt) : requireTimestamp(existingRow.createdAt)
-      const metadata = withCreatedAtMetadata({ ...message.metadata, createdAt: persistedCreatedAt })
-
-      await databaseService.upsert(
-        TABLES.THREAD_MESSAGE,
-        rowId,
-        {
-          threadId,
-          messageId,
-          role,
-          parts,
-          metadata,
-          createdAt: existingRow ? existingRow.createdAt : new Date(persistedCreatedAt),
-        },
-        ThreadMessageRowSchema,
-        { mutation: 'content' },
-      )
-    })
-    await Promise.all(upsertPromises)
-  }
-
-  async listMessages(threadId: RecordIdRef): Promise<ChatMessage[]> {
-    const threadRef = toThreadRef(threadId)
-    const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM threadMessage
-      WHERE threadId = ${threadRef}
-      ORDER BY createdAt ASC, id ASC
-    `)
-
-    return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
-  }
-
-  async listMessageHistoryPage(params: {
-    threadId: RecordIdRef
-    take: number
-    beforeMessageId?: string
-  }): Promise<MessageHistoryPage> {
-    const threadRef = toThreadRef(params.threadId)
-    return listMessageHistoryPage(threadPaginationConfig, {
-      parentId: threadRef,
-      take: params.take,
-      beforeMessageId: params.beforeMessageId,
-    })
-  }
-
-  async listMessagesAfterCursor(threadId: RecordIdRef, afterMessageId?: string): Promise<ChatMessage[]> {
-    const threadRef = toThreadRef(threadId)
-    const cursorMessageId = afterMessageId?.trim()
-    if (!cursorMessageId) {
-      return this.listMessages(threadRef)
-    }
-
-    const cursorRow = await databaseService.findOne(
-      TABLES.THREAD_MESSAGE,
-      { threadId: threadRef, messageId: cursorMessageId },
-      CursorRowSchema,
-    )
-
-    if (!cursorRow) {
-      throw new Error(`Thread cursor message not found: ${cursorMessageId}`)
-    }
-
-    const cursorCreatedAt = cursorRow.createdAt
-    const cursorId = toThreadMessageRowId(threadRef, cursorMessageId)
-    const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM threadMessage
-      WHERE threadId = ${threadRef}
-        AND (
-          createdAt > ${cursorCreatedAt}
-          OR (createdAt = ${cursorCreatedAt} AND id > ${cursorId})
-        )
-      ORDER BY createdAt ASC, id ASC
-    `)
-
-    return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
-  }
-
-  async listRecentMessages(threadId: RecordIdRef, limit: number): Promise<ChatMessage[]> {
-    const threadRef = toThreadRef(threadId)
-    const rows = await databaseService.query<unknown>(surql`
-      SELECT * FROM threadMessage
-      WHERE threadId = ${threadRef}
-      ORDER BY createdAt DESC, id DESC
-      LIMIT ${Math.max(1, limit)}
-    `)
-
-    return rows
-      .map((row) => ThreadMessageRowSchema.parse(row))
-      .reverse()
-      .map((row) => toChatMessage(row))
-  }
-
-  async searchMessages(params: {
-    threadId: RecordIdRef
-    role: 'user' | 'assistant'
-    query: string
-    limit: number
-  }): Promise<Array<{ id: string; role: 'user' | 'assistant'; createdAt: string; content: string }>> {
-    const normalizedQuery = params.query.trim().toLowerCase()
-    if (!normalizedQuery) return []
-
-    const messages = await this.listMessages(toThreadRef(params.threadId))
-    return messages
-      .filter((message) => message.role === params.role)
-      .map((message) => ({
-        id: message.id,
-        role: message.role as 'user' | 'assistant',
-        createdAt: new Date(requireTimestamp(message.metadata?.createdAt)).toISOString(),
-        content: message.parts
-          .flatMap((part) => (part.type === 'text' && typeof part.text === 'string' ? [part.text] : []))
-          .join('\n')
-          .trim(),
-      }))
-      .filter((item) => item.content.length > 0 && item.content.toLowerCase().includes(normalizedQuery))
-      .slice(-Math.max(1, params.limit))
-  }
-
-  async addUserMessage(params: {
-    messageId: RecordIdRef
-    threadId: RecordIdRef
-    content: string
-  }): Promise<ChatMessage> {
-    const threadRef = toThreadRef(params.threadId)
-    const message: ChatMessage = {
-      id: toMessageId(params.messageId),
-      role: 'user',
-      parts: [{ type: 'text', text: params.content }],
-      metadata: { createdAt: Date.now() },
-    }
-
-    await this.upsertMessages({ threadId: threadRef, messages: [message] })
-    return message
-  }
-
-  async addAgentMessage(params: {
-    messageId: RecordIdRef
-    threadId: RecordIdRef
-    parts: ChatMessage['parts']
-    metadata?: ChatMessage['metadata']
-  }): Promise<ChatMessage> {
-    const threadRef = toThreadRef(params.threadId)
-    const message: ChatMessage = {
-      id: toMessageId(params.messageId),
-      role: 'assistant',
-      parts: params.parts,
-      metadata: withCreatedAtMetadata(params.metadata, Date.now()),
-    }
-
-    await this.upsertMessages({ threadId: threadRef, messages: [message] })
-    return message
-  }
-
-  async ensureBootstrapWelcomeMessage(params: { threadId: RecordIdRef; agentId: string; text: string }): Promise<void> {
-    const threadRef = toThreadRef(params.threadId)
-    const existingRow = await databaseService.findOne(
-      TABLES.THREAD_MESSAGE,
-      { threadId: threadRef },
-      ThreadMessageExistingRowSchema,
-    )
-    if (existingRow) return
-
-    const messageText = params.text.trim()
-    if (!messageText) return
-
-    await this.upsertMessages({
-      threadId: threadRef,
-      messages: [
-        {
-          id: Bun.randomUUIDv7(),
-          role: 'assistant',
-          parts: [{ type: 'text', text: messageText }],
-          metadata: {
-            agentId: params.agentId,
-            agentName: agentDisplayNames[params.agentId] ?? params.agentId,
-            createdAt: Date.now(),
-          },
-        },
-      ],
-    })
-  }
-}
-
-export const threadMessageService = new ThreadMessageService()

package/src/services/thread-plan-registry.service.ts

@@ -1,22 +0,0 @@
-import type { PlanRunRecord, SerializableExecutionPlan } from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import { planRunService } from './plan-run.service'
-
-class ThreadPlanRegistryService {
-  async listActiveRuns(threadId: RecordIdInput): Promise<PlanRunRecord[]> {
-    return planRunService.getActiveRunRecords(threadId)
-  }
-
-  async countActiveRuns(threadId: RecordIdInput): Promise<number> {
-    const runs = await this.listActiveRuns(threadId)
-    return runs.length
-  }
-
-  async listActivePlans(threadId: RecordIdInput): Promise<SerializableExecutionPlan[]> {
-    const runs = await this.listActiveRuns(threadId)
-    return Promise.all(runs.map((run) => planRunService.toSerializablePlan(run)))
-  }
-}
-
-export const threadPlanRegistryService = new ThreadPlanRegistryService()

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

@@ -1,39 +0,0 @@
-import { THREAD } from '@lota-sdk/shared'
-
-import { chatLogger } from '../config/logger'
-import type { RecordIdRef } from '../db/record-id'
-import { createHelperModelRuntime } from '../runtime/helper-model'
-import { deriveTitle, limitTitleWords, normalizeTitle } from '../runtime/title-helpers'
-import { createThreadTitleGeneratorAgent, THREAD_TITLE_GENERATOR_PROMPT } from '../system-agents/title-generator.agent'
-import { threadService } from './thread.service'
-
-const THREAD_TITLE_TIMEOUT_MS = 30_000
-
-class ThreadTitleService {
-  helperRuntime = createHelperModelRuntime()
-
-  async generateAndPersistTitle(threadId: RecordIdRef, sourceText: string): Promise<void> {
-    let title = ''
-    try {
-      title = normalizeTitle(
-        await this.helperRuntime.generateHelperText({
-          tag: 'thread-title',
-          createAgent: createThreadTitleGeneratorAgent,
-          defaultSystemPrompt: THREAD_TITLE_GENERATOR_PROMPT,
-          timeoutMs: THREAD_TITLE_TIMEOUT_MS,
-          messages: [{ role: 'user', content: sourceText }],
-        }),
-      )
-    } catch (error) {
-      chatLogger.warn`Failed to generate thread title via LLM (non-fatal): ${error}`
-    }
-
-    if (!title) {
-      title = limitTitleWords(deriveTitle(sourceText || THREAD.DEFAULT_TITLE))
-    }
-
-    await threadService.update(threadId, { title, nameGenerated: true })
-  }
-}
-
-export const threadTitleService = new ThreadTitleService()