@lota-sdk/core 0.1.18 → 0.1.20

package/src/queues/queue-factory.ts

@@ -4,6 +4,7 @@ import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
 import { getRedisConnectionForBullMQ } from '../redis'
+import { queueJobService } from '../services/queue-job.service'
 import {
   attachWorkerEvents,
   createTracedWorkerProcessor,
@@ -26,7 +27,7 @@ interface QueueFactoryConfigBase {
 }
 
 interface QueueFactoryConfigInline<TJob> extends QueueFactoryConfigBase {
-  processor: (job: Job<TJob>) => Promise<void>
+  processor: (job: Job<TJob>) => Promise<unknown>
   processorPath?: never
 }
 
@@ -45,15 +46,34 @@ export interface QueueFactory<TJob> {
 
 export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): QueueFactory<TJob> {
   let _queue: Queue<TJob, unknown, string> | null = null
+  let _queueConnection: IORedis | null = null
 
   const getConnection = () => config.connectionProvider?.() ?? getRedisConnectionForBullMQ()
 
   const getQueue = (): Queue<TJob, unknown, string> => {
-    if (!_queue) {
+    const connection = getConnection()
+    const shouldRecreateQueue =
+      _queue === null ||
+      _queueConnection === null ||
+      _queueConnection !== connection ||
+      _queueConnection.status === 'close' ||
+      _queueConnection.status === 'end'
+
+    if (shouldRecreateQueue) {
+      if (_queue) {
+        void _queue.close().catch((error: unknown) => {
+          serverLogger.warn`Failed to close stale ${config.displayName} queue: ${error}`
+        })
+      }
+
       _queue = new Queue<TJob, unknown, string>(config.name, {
-        connection: getConnection(),
+        connection,
         defaultJobOptions: { ...DEFAULT_JOB_RETENTION, ...config.defaultJobOptions },
       })
+      _queueConnection = connection
+    }
+    if (_queue === null) {
+      throw new Error(`Failed to initialize queue: ${config.name}`)
     }
     return _queue
   }
@@ -63,7 +83,16 @@ export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): Queu
   const toData = (job: TJob) => job as Parameters<QueueAdd>[1]
 
   const enqueue = async (job: TJob, options?: JobsOptions): Promise<void> => {
-    await getQueue().add(jobName, toData(job), options)
+    const queuedJob = await getQueue().add(jobName, toData(job), options)
+    await queueJobService.recordEnqueued({
+      queueName: config.name,
+      id: queuedJob.id,
+      name: queuedJob.name,
+      data: queuedJob.data,
+      opts: queuedJob.opts,
+      attemptsMade: queuedJob.attemptsMade,
+      timestamp: queuedJob.timestamp,
+    })
   }
 
   const startWorker = (options: { registerSignals?: boolean } = {}): WorkerHandle => {

package/src/runtime/chat-run-registry.ts

@@ -1,6 +1,10 @@
 export class ChatRunRegistry {
   private controllers = new Map<string, AbortController>()
 
+  has(runId: string): boolean {
+    return this.controllers.has(runId)
+  }
+
   register(runId: string, controller: AbortController): void {
     this.controllers.set(runId, controller)
   }

package/src/runtime/context-compaction.ts

@@ -101,6 +101,90 @@ function sanitizeStateText(value: string): string | null {
   return normalized
 }
 
+function buildExistingWorkstreamStateForCompactionPrompt(state: WorkstreamState): Record<string, unknown> {
+  const currentPlanText = state.currentPlan ? sanitizeStateText(state.currentPlan.text) : null
+
+  const activeConstraints = state.activeConstraints
+    .map((constraint) => ({
+      id: constraint.id,
+      text: sanitizeStateText(constraint.text),
+      source: constraint.source,
+      approved: constraint.approved,
+      sourceMessageIds: constraint.sourceMessageIds,
+    }))
+    .filter((constraint): constraint is typeof constraint & { text: string } => Boolean(constraint.text))
+
+  const keyDecisions = state.keyDecisions
+    .map((decision) => ({
+      id: decision.id,
+      decision: sanitizeStateText(decision.decision),
+      rationale: sanitizeStateText(decision.rationale),
+      agent: decision.agent,
+      sourceMessageIds: decision.sourceMessageIds,
+      confidence: decision.confidence,
+    }))
+    .filter((decision): decision is typeof decision & { decision: string; rationale: string } =>
+      Boolean(decision.decision && decision.rationale),
+    )
+
+  const tasks = state.tasks
+    .map((task) => ({
+      id: task.id,
+      title: sanitizeStateText(task.title),
+      status: task.status,
+      owner: sanitizeStateText(task.owner),
+      externalId: task.externalId,
+      source: task.source,
+      sourceMessageIds: task.sourceMessageIds,
+    }))
+    .filter((task): task is typeof task & { title: string; owner: string } => Boolean(task.title && task.owner))
+
+  const openQuestions = state.openQuestions
+    .map((question) => ({
+      id: question.id,
+      text: sanitizeStateText(question.text),
+      source: question.source,
+      sourceMessageIds: question.sourceMessageIds,
+    }))
+    .filter((question): question is typeof question & { text: string } => Boolean(question.text))
+
+  const artifacts = state.artifacts
+    .map((artifact) => ({
+      id: artifact.id,
+      name: sanitizeStateText(artifact.name),
+      type: artifact.type,
+      pointer: sanitizeStateText(artifact.pointer),
+    }))
+    .filter((artifact): artifact is typeof artifact & { name: string; pointer: string } =>
+      Boolean(artifact.name && artifact.pointer),
+    )
+
+  const agentContributions = state.agentContributions
+    .map((note) => ({ id: note.id, agent: note.agent, summary: sanitizeStateText(note.summary) }))
+    .filter((note): note is typeof note & { summary: string } => Boolean(note.summary))
+
+  return {
+    currentPlan: currentPlanText
+      ? {
+          id: state.currentPlan?.id,
+          text: currentPlanText,
+          source: state.currentPlan?.source,
+          approved: state.currentPlan?.approved,
+          sourceMessageIds: state.currentPlan?.sourceMessageIds ?? [],
+        }
+      : null,
+    activeConstraints,
+    keyDecisions,
+    tasks,
+    openQuestions,
+    risks: state.risks.map((risk) => sanitizeStateText(risk)).filter((risk): risk is string => Boolean(risk)),
+    artifacts,
+    agentContributions,
+    approvedBy: state.approvedBy ? sanitizeStateText(state.approvedBy) : undefined,
+    approvalNote: state.approvalNote ? sanitizeStateText(state.approvalNote) : undefined,
+  }
+}
+
 function createStableId(prefix: string, ...parts: Array<string | number | undefined>): string {
   const payload = parts
     .map((part) => (part === undefined ? '' : String(part)))
@@ -488,7 +572,7 @@ export function buildContextCompactionPrompt(params: ContextCompactionPromptPara
     params.previousSummary.trim() || 'None',
     '</previous-summary>',
     '<existing-workstream-state>',
-    JSON.stringify(params.existingState),
+    JSON.stringify(buildExistingWorkstreamStateForCompactionPrompt(params.existingState)),
     '</existing-workstream-state>',
     '<new-messages>',
     params.transcript || 'None',
@@ -605,27 +689,34 @@ export function createContextCompactionRuntime(
       .filter((constraint): constraint is typeof constraint & { text: string } => Boolean(constraint.text))
 
     const openQuestions = state.openQuestions
-      .map((question) => ({ ...question, text: sanitizeStateText(question.text) }))
-      .filter((question): question is typeof question & { text: string } => Boolean(question.text))
+      .map((question) => sanitizeStateText(question.text))
+      .filter((question): question is string => Boolean(question))
 
     const decisions = state.keyDecisions
       .map((decision) => ({
-        ...decision,
+        agent: decision.agent,
         decision: sanitizeStateText(decision.decision),
         rationale: sanitizeStateText(decision.rationale),
+        confidence: decision.confidence,
       }))
       .filter((decision): decision is typeof decision & { decision: string; rationale: string } =>
         Boolean(decision.decision && decision.rationale),
       )
 
     const tasks = state.tasks
-      .map((task) => ({ ...task, title: sanitizeStateText(task.title), owner: sanitizeStateText(task.owner) }))
+      .map((task) => ({
+        title: sanitizeStateText(task.title),
+        status: task.status,
+        owner: sanitizeStateText(task.owner),
+        externalId: task.externalId,
+        source: task.source,
+      }))
       .filter((task): task is typeof task & { title: string; owner: string } => Boolean(task.title && task.owner))
 
     const artifacts = state.artifacts
       .map((artifact) => ({
-        ...artifact,
         name: sanitizeStateText(artifact.name),
+        type: artifact.type,
         pointer: sanitizeStateText(artifact.pointer),
       }))
       .filter((artifact): artifact is typeof artifact & { name: string; pointer: string } =>
@@ -633,7 +724,7 @@ export function createContextCompactionRuntime(
       )
 
     const agentContributions = state.agentContributions
-      .map((note) => ({ ...note, summary: sanitizeStateText(note.summary) }))
+      .map((note) => ({ agent: note.agent, summary: sanitizeStateText(note.summary) }))
       .filter((note): note is typeof note & { summary: string } => Boolean(note.summary))
 
     const payload = {
@@ -661,12 +752,9 @@ export function createContextCompactionRuntime(
       artifacts,
       agentContributions,
       advisory: {
-        approvedBy: state.approvedBy ?? null,
-        approvedAt: state.approvedAt ?? null,
-        approvalMessageId: state.approvalMessageId ?? null,
-        approvalNote: state.approvalNote ?? null,
+        approvedBy: state.approvedBy ? sanitizeStateText(state.approvedBy) : null,
+        approvalNote: state.approvalNote ? sanitizeStateText(state.approvalNote) : null,
       },
-      lastUpdated: state.lastUpdated,
     }
 
     return ['<workstream-state>', JSON.stringify(payload, null, 2), '</workstream-state>'].join('\n')

package/src/runtime/memory-prompts-fact.ts

@@ -1,3 +1,5 @@
+import { formatUtcPromptDate } from '../utils/date-time'
+
 export function getFactRetrievalMessages(
   parsedMessages: string,
   customPrompt?: string,
@@ -38,7 +40,7 @@ Hard rules:
 - Prefer returning fewer items. If uncertain, return an empty list.
 - Max ${maxFacts} facts.
 
-Today's date is ${new Date().toISOString().split('T')[0]}.
+Today's date is ${formatUtcPromptDate(new Date())}.
 ${baseInstructions}`
 
   const userPrompt = `Conversation:\n${parsedMessages}`

package/src/runtime/runtime-config.ts

@@ -292,7 +292,7 @@ export const LOTA_RUNTIME_ENV_KEYS = Object.freeze([
   'SURREALDB_PASSWORD',
   'REDIS_URL',
   'AI_GATEWAY_URL',
-  'LOTA_KEY',
+  'AI_GATEWAY_KEY',
   'AI_EMBEDDING_MODEL',
   'S3_ENDPOINT',
   'S3_BUCKET',

package/src/runtime/runtime-worker-registry.ts

@@ -1,3 +1,4 @@
+import { startAutonomousJobWorker } from '../queues/autonomous-job.queue'
 import { startContextCompactionWorker } from '../queues/context-compaction.queue'
 import { startDelayedNodePromotionWorker } from '../queues/delayed-node-promotion.queue'
 import { scheduleRecurringConsolidation, startMemoryConsolidationWorker } from '../queues/memory-consolidation.queue'
@@ -9,6 +10,7 @@ import { startSkillExtractionWorker } from '../queues/skill-extraction.queue'
 import { startWorkstreamTitleGenerationWorker } from '../queues/workstream-title-generation.queue'
 
 export interface LotaRuntimeWorkerStartRegistry {
+  autonomousJob: typeof startAutonomousJobWorker
   contextCompaction: typeof startContextCompactionWorker
   delayedNodePromotion: typeof startDelayedNodePromotionWorker
   memoryConsolidation: typeof startMemoryConsolidationWorker
@@ -37,6 +39,7 @@ export interface LotaRuntimeWorkerExtensions {
 export function buildRuntimeWorkerRegistry(extraWorkers?: LotaRuntimeWorkerExtensions): LotaRuntimeWorkers {
   return {
     start: {
+      autonomousJob: startAutonomousJobWorker,
       contextCompaction: startContextCompactionWorker,
       delayedNodePromotion: startDelayedNodePromotionWorker,
       memoryConsolidation: startMemoryConsolidationWorker,