@lota-sdk/core 0.1.5 → 0.1.7

package/src/utils/sse-keepalive.ts

@@ -0,0 +1,40 @@
+const KEEPALIVE_COMMENT = new TextEncoder().encode(': keepalive\n\n')
+const DEFAULT_KEEPALIVE_INTERVAL_MS = 20_000
+
+/**
+ * Wraps an SSE Response body with periodic keepalive comments.
+ * SSE comments (`: keepalive\n\n`) are ignored by standard SSE parsers,
+ * so no client changes are needed.
+ */
+export function wrapResponseWithKeepalive(response: Response, intervalMs = DEFAULT_KEEPALIVE_INTERVAL_MS): Response {
+  const body = response.body
+  if (!body) return response
+
+  let intervalHandle: ReturnType<typeof setInterval> | null = null
+
+  const transformed = body.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      start(controller) {
+        intervalHandle = setInterval(() => {
+          try {
+            controller.enqueue(KEEPALIVE_COMMENT)
+          } catch {
+            if (intervalHandle) clearInterval(intervalHandle)
+          }
+        }, intervalMs)
+      },
+      transform(chunk, controller) {
+        controller.enqueue(chunk)
+      },
+      flush() {
+        if (intervalHandle) clearInterval(intervalHandle)
+      },
+    }),
+  )
+
+  return new Response(transformed, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText,
+  })
+}

package/src/workers/bootstrap.ts

@@ -1,8 +1,31 @@
 import { configureLogger, serverLogger } from '../config/logger'
-import { databaseService } from '../db/service'
+import { LOTA_SDK_DATABASE_NAME } from '../db/sdk-database'
+import { SurrealDBService, databaseService, setDatabaseService } from '../db/service'
 import { connectWithStartupRetry, waitForDatabaseBootstrap } from '../db/startup'
 import { getConfiguredPluginDatabaseConnector } from '../runtime/runtime-extensions'
 
+/**
+ * Sandboxed BullMQ workers run in separate child processes where createLotaRuntime
+ * was never called, so the global databaseService proxy has no backing instance.
+ * Create one from env vars so the proxy resolves.
+ */
+function getRequiredEnv(key: string): string {
+  const value = process.env[key]
+  if (!value) throw new Error(`Missing required env var: ${key}`)
+  return value
+}
+
+function ensureDatabaseServiceConfigured(): void {
+  const db = new SurrealDBService({
+    url: getRequiredEnv('SURREALDB_URL'),
+    namespace: getRequiredEnv('SURREALDB_NAMESPACE'),
+    database: LOTA_SDK_DATABASE_NAME,
+    username: process.env.SURREALDB_USER,
+    password: process.env.SURREALDB_PASSWORD,
+  })
+  setDatabaseService(db)
+}
+
 let sandboxedWorkerRuntimePromise: Promise<void> | null = null
 
 export async function initializeSandboxedWorkerRuntime(): Promise<void> {
@@ -14,6 +37,8 @@ export async function initializeSandboxedWorkerRuntime(): Promise<void> {
   sandboxedWorkerRuntimePromise = (async () => {
     await configureLogger()
 
+    ensureDatabaseServiceConfigured()
+
     await connectWithStartupRetry({
       connect: () => databaseService.connect(),
       label: 'sandboxed worker AI database runtime',

package/src/workers/memory-consolidation.worker.ts

@@ -276,13 +276,6 @@ async function cleanupOrphanedRelations(): Promise<number> {
   return result[0]?.count ?? 0
 }
 
-async function pruneOldOrgActions(): Promise<number> {
-  const result = await databaseService.query<{ count: number }>(
-    new BoundQuery(`DELETE ${TABLES.ORG_ACTION} WHERE createdAt < time::now() - 90d RETURN count() AS count`),
-  )
-  return result[0]?.count ?? 0
-}
-
 const handler = async (job: SandboxedJob<MemoryConsolidationJob>) => {
   const targetScope = job.data.scopeId
 
@@ -305,9 +298,8 @@ const handler = async (job: SandboxedJob<MemoryConsolidationJob>) => {
     const collapsed = await collapseSupersedeCh()
     const decayed = await decayImportance()
     const orphaned = await cleanupOrphanedRelations()
-    const prunedActions = await pruneOldOrgActions()
 
-    serverLogger.info`Memory consolidation complete (merged: ${totalMerged}, pruned: ${pruned}, collapsed: ${collapsed}, decayed: ${decayed}, orphaned relations: ${orphaned}, pruned actions: ${prunedActions})`
+    serverLogger.info`Memory consolidation complete (merged: ${totalMerged}, pruned: ${pruned}, collapsed: ${collapsed}, decayed: ${decayed}, orphaned relations: ${orphaned})`
   } catch (error) {
     const serialized = toSandboxedWorkerError(error, 'Memory consolidation job failed')
     serverLogger.error`${serialized.message}`