@lota-sdk/core 0.4.8 → 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/rerank.service.ts

@@ -1,156 +0,0 @@
-import { z } from 'zod'
-
-import { OPENROUTER_FAST_RERANK_MODEL_ID } from '../config/model-constants'
-import { normalizeDirectOpenRouterModelId, resolveOpenRouterApiKey } from '../openrouter/direct-provider'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-
-const OPENROUTER_RERANK_URL = 'https://openrouter.ai/api/v1/rerank' as const
-
-const RerankResponseSchema = z
-  .object({
-    model: z.string().optional(),
-    results: z.array(
-      z
-        .object({
-          index: z.number().int().nonnegative().optional(),
-          relevance_score: z.number().optional(),
-          document: z.union([z.string(), z.object({ text: z.string().optional() }).passthrough()]).optional(),
-        })
-        .passthrough(),
-    ),
-    usage: z.object({ search_units: z.number().optional(), cost: z.number().optional() }).passthrough().optional(),
-  })
-  .passthrough()
-
-export interface RerankDocument {
-  id: string
-  text: string
-}
-
-export interface RerankResultItem extends RerankDocument {
-  index: number
-  relevanceScore: number | null
-}
-
-export interface RerankUsage {
-  searchUnits?: number
-  cost?: number
-}
-
-export interface RerankResult {
-  modelId: string
-  results: RerankResultItem[]
-  usage?: RerankUsage
-}
-
-function clampTopN(topN: number | undefined, total: number): number {
-  if (!Number.isFinite(topN)) return total
-  return Math.max(1, Math.min(total, Math.trunc(topN as number)))
-}
-
-function readConfiguredRerankModelId(): string | null {
-  try {
-    return getRuntimeConfig().memory.rerankerModelId.trim()
-  } catch {
-    return null
-  }
-}
-
-function resolveRerankModelId(modelId?: string): string {
-  const explicit = modelId?.trim()
-  if (explicit) return normalizeDirectOpenRouterModelId(explicit)
-
-  const configured = readConfiguredRerankModelId()
-  if (configured) return normalizeDirectOpenRouterModelId(configured)
-
-  return OPENROUTER_FAST_RERANK_MODEL_ID
-}
-
-function matchRerankedDocument(
-  candidate: z.infer<typeof RerankResponseSchema>['results'][number],
-  documents: RerankDocument[],
-): RerankDocument | null {
-  if (typeof candidate.index === 'number' && candidate.index >= 0 && candidate.index < documents.length) {
-    return documents[candidate.index] ?? null
-  }
-
-  const text =
-    typeof candidate.document === 'string'
-      ? candidate.document
-      : typeof candidate.document?.text === 'string'
-        ? candidate.document.text
-        : null
-  if (!text) return null
-
-  return documents.find((document) => document.text === text) ?? null
-}
-
-class RerankService {
-  async rerankDocuments(params: {
-    query: string
-    documents: RerankDocument[]
-    topN?: number
-    modelId?: string
-  }): Promise<RerankResult> {
-    if (params.documents.length === 0) {
-      return { modelId: resolveRerankModelId(params.modelId), results: [] }
-    }
-
-    const apiKey = resolveOpenRouterApiKey()
-    const modelId = resolveRerankModelId(params.modelId)
-    const topN = clampTopN(params.topN, params.documents.length)
-
-    const response = await fetch(OPENROUTER_RERANK_URL, {
-      method: 'POST',
-      headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        model: modelId,
-        query: params.query,
-        documents: params.documents.map((document) => document.text),
-        top_n: topN,
-      }),
-    })
-
-    const responseText = await response.text()
-    let payload: unknown = responseText
-    try {
-      payload = JSON.parse(responseText)
-    } catch {}
-
-    if (!response.ok) {
-      throw new Error(`OpenRouter rerank failed (${response.status}): ${responseText}`)
-    }
-
-    const parsed = RerankResponseSchema.parse(payload)
-    const seen = new Set<string>()
-    const results: RerankResultItem[] = []
-
-    for (const item of parsed.results) {
-      const matched = matchRerankedDocument(item, params.documents)
-      if (!matched || seen.has(matched.id)) continue
-      seen.add(matched.id)
-
-      results.push({
-        id: matched.id,
-        text: matched.text,
-        index: item.index ?? params.documents.findIndex((document) => document.id === matched.id),
-        relevanceScore: typeof item.relevance_score === 'number' ? item.relevance_score : null,
-      })
-
-      if (results.length >= topN) break
-    }
-
-    return {
-      modelId: parsed.model?.trim() || modelId,
-      results,
-      usage: parsed.usage
-        ? {
-            ...(parsed.usage.search_units !== undefined ? { searchUnits: parsed.usage.search_units } : {}),
-            ...(parsed.usage.cost !== undefined ? { cost: parsed.usage.cost } : {}),
-          }
-        : undefined,
-    }
-  }
-}
-
-export const rerankService = new RerankService()

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()