mixdog 0.9.19 → 0.9.21

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -218,14 +218,16 @@ export function warmupEmbeddingProvider() {
   return _warmupPromise
 }
 
-export async function embedText(text) {
+export async function embedText(text, options = {}) {
   const clean = String(text ?? '').trim()
   if (!clean) return []
   const cacheKey = `${MODEL_ID}\n${clean}`
   const cached = getCachedEmbedding(cacheKey)
   if (cached) return [...cached]
 
-  const result = await sendToWorker('embed', { text: clean })
+  // Interactive query embeds pass { priority: true } so the worker can
+  // queue-jump them ahead of background flush embed-batch work.
+  const result = await sendToWorker('embed', { text: clean, priority: options?.priority === true })
   if (!result.dims) throw new Error(`embed result missing dims (model=${MODEL_ID})`)
   const resultDims = result.dims
   if (cachedDims && resultDims !== cachedDims) {

package/src/runtime/memory/lib/embedding-worker.mjs

@@ -57,6 +57,47 @@ let _idleTimer = null
 let _embedInFlight = false
 const _msgQueue = []
 let ortPatched = false
+// Control ops must never be overtaken by a priority embed: crossing a queued
+// configure/dispose/warmup would run inference against pre-configure or
+// post-dispose model state.
+const CONTROL_ACTIONS = new Set(['configure', 'dispose', 'warmup'])
+// Anti-starvation cap: max times a single queued flush embed-batch may be
+// overtaken by priority embeds before it is allowed to run. Bounds how long a
+// flush (which may hold DB row locks in flushEmbeddingDirty) can be delayed
+// under sustained interactive traffic. MIXDOG_EMBED_PRIORITY_SKIP_CAP overrides.
+const _envSkipCap = Number(process.env.MIXDOG_EMBED_PRIORITY_SKIP_CAP)
+const PRIORITY_SKIP_CAP = Number.isFinite(_envSkipCap) && _envSkipCap >= 1 ? Math.floor(_envSkipCap) : 8
+// Queue with a single priority lane. Interactive query embeds (msg.priority)
+// jump ahead of background flush embed-batch work so an in-progress large
+// flush cannot starve a live recall's query vector. Constraints:
+//  - never cross a queued control op (insert only after the last one),
+//  - stay in FIFO order behind already-queued priority embeds,
+//  - never preempt the running ONNX call,
+//  - never overtake the same flush batch more than PRIORITY_SKIP_CAP times.
+function enqueue(msg) {
+  if (!msg?.priority) { _msgQueue.push(msg); return }
+  // Barrier: insertion must land after the last queued control op.
+  let lastControl = -1
+  for (let i = 0; i < _msgQueue.length; i++) {
+    if (CONTROL_ACTIONS.has(_msgQueue[i].action)) lastControl = i
+  }
+  // In the tail after that barrier, priority embeds cluster first, then the
+  // background embed-batch entries — advance to the first embed-batch so this
+  // embed sits behind existing priority embeds but ahead of flush work.
+  let pos = lastControl + 1
+  while (pos < _msgQueue.length && _msgQueue[pos].action !== 'embed-batch') pos++
+  if (pos < _msgQueue.length) {
+    const batch = _msgQueue[pos]
+    if ((batch._priorityJumps || 0) >= PRIORITY_SKIP_CAP) {
+      // This flush batch has been overtaken enough — yield so it makes
+      // progress (and can release any row locks) before more query embeds run.
+      _msgQueue.splice(pos + 1, 0, msg)
+      return
+    }
+    batch._priorityJumps = (batch._priorityJumps || 0) + 1
+  }
+  _msgQueue.splice(pos, 0, msg)
+}
 // Actions that must hold the in-flight guard for their entire async duration.
 // Inference actions hold it so concurrent embeds serialize; configure/dispose
 // hold it so a new embed arriving mid-await cannot race extractorPromise
@@ -209,7 +250,7 @@ async function processMessage(msg) {
     switch (action) {
       case 'embed-batch': {
         if (_embedInFlight) {
-          _msgQueue.push(msg)
+          enqueue(msg)
           return
         }
         _embedInFlight = true
@@ -236,7 +277,7 @@ async function processMessage(msg) {
       case 'embed': {
         if (_embedInFlight) {
           // Re-queue behind current — serialize all embed calls
-          _msgQueue.push(msg)
+          enqueue(msg)
           return
         }
         _embedInFlight = true
@@ -254,7 +295,7 @@ async function processMessage(msg) {
       }
       case 'warmup': {
         if (_embedInFlight) {
-          _msgQueue.push(msg)
+          enqueue(msg)
           return
         }
         _embedInFlight = true
@@ -272,7 +313,7 @@ async function processMessage(msg) {
       }
       case 'configure': {
         if (_embedInFlight) {
-          _msgQueue.push(msg)
+          enqueue(msg)
           return
         }
         _embedInFlight = true
@@ -293,7 +334,7 @@ async function processMessage(msg) {
       }
       case 'dispose': {
         if (_embedInFlight) {
-          _msgQueue.push(msg)
+          enqueue(msg)
           return
         }
         _embedInFlight = true
@@ -332,7 +373,7 @@ parentPort.on('message', async (msg) => {
   // here, a new embed arriving mid-dispose would bypass the queue and race
   // extractorPromise reset / ext.dispose() against the prior tear-down.
   if (_embedInFlight) {
-    _msgQueue.push(msg)
+    enqueue(msg)
     return
   }
   await processMessage(msg)