mixdog 0.9.147 → 0.9.149

package/src/runtime/media/store.mjs

@@ -71,8 +71,11 @@ function indexSignature(path) {
   try {
     const info = statSync(path);
     return `${info.mtimeMs}:${info.ctimeMs}:${info.size}`;
-  } catch {
-    return 'missing';
+  } catch (error) {
+    // Only an absent file is "missing". Reporting EACCES/EIO as missing let the
+    // read path cache an empty catalog for a store that is actually unreadable.
+    if (error?.code === 'ENOENT') return 'missing';
+    throw error;
   }
 }
 
@@ -91,14 +94,22 @@ function readIndex() {
     indexCacheHits += 1;
     return indexCacheAssets;
   }
+  let raw;
   try {
-    const raw = readFileSync(path, 'utf8');
-    const parsed = JSON.parse(raw);
-    indexDiskReads += 1;
-    return rememberIndex(path, signature, Array.isArray(parsed?.assets) ? parsed.assets : []);
-  } catch {
-    return rememberIndex(path, signature, []);
+    raw = readFileSync(path, 'utf8');
+  } catch (error) {
+    // A missing index file is a genuinely empty catalog (first run). Every
+    // OTHER read failure is not: answering with an empty list made the next
+    // save/delete write that emptiness back over every existing asset entry.
+    if (error?.code === 'ENOENT') return rememberIndex(path, signature, []);
+    throw error;
   }
+  const parsed = JSON.parse(raw);
+  if (!parsed || !Array.isArray(parsed.assets)) {
+    throw new Error(`media index is malformed: ${path}`);
+  }
+  indexDiskReads += 1;
+  return rememberIndex(path, signature, parsed.assets);
 }
 
 function writeIndex(assets) {
@@ -107,6 +118,20 @@ function writeIndex(assets) {
   rememberIndex(path, indexSignature(path), assets);
 }
 
+/**
+ * The one catalog read-modify-write. Every mutation (migrate, save, duration
+ * backfill, delete) holds index.lock across a fresh readIndex() and writes back
+ * only what the callback returns, so a concurrent CLI/desktop generation can
+ * never lose an entry — and a read that FAILS (rather than being absent)
+ * propagates out of the lock instead of writing an empty catalog over it.
+ */
+function mutateIndex(mutate) {
+  withFileLockSync(indexLockPath(), () => {
+    const next = mutate(readIndex());
+    if (next) writeIndex(next);
+  });
+}
+
 export function mediaStoreCacheStats() {
   return {
     indexDiskReads,
@@ -158,8 +183,7 @@ function storedAssetPath(file) {
 
 /** Move flat v1 assets into kind/provider/model/date folders without losing old indexes. */
 function migrateAssetLayout() {
-  withFileLockSync(indexLockPath(), () => {
-    const current = readIndex();
+  mutateIndex((current) => {
     let changed = false;
     const assets = current.map((entry) => {
       const targetFile = organizedAssetFile(entry);
@@ -181,7 +205,7 @@ function migrateAssetLayout() {
         return entry;
       }
     });
-    if (changed) writeIndex(assets);
+    return changed ? assets : null;
   });
 }
 
@@ -213,9 +237,7 @@ export function saveMediaAsset({ kind, lane, model, prompt, options = {}, mime,
   // The gallery is NOT capped (user). An entry-count trim used to unlink the
   // oldest files here, which is data loss nobody asked for: a generated asset
   // leaves this store only through an explicit delete.
-  withFileLockSync(indexLockPath(), () => {
-    writeIndex([entry, ...readIndex()]);
-  });
+  mutateIndex((assets) => [entry, ...assets]);
   // The first gallery paint after a generation would otherwise be the one that
   // pays for the tile rendition; build it now, off the caller's path.
   void ensureRendition({
@@ -248,12 +270,11 @@ function getMediaAsset(id) {
  *  survives a restart without decoding the clip again. */
 function rememberDuration(entry, durationSeconds) {
   if (!durationSeconds || entry.durationSeconds === durationSeconds) return;
-  withFileLockSync(indexLockPath(), () => {
-    const assets = readIndex();
+  mutateIndex((assets) => {
     const row = assets.find((item) => item.id === entry.id);
-    if (!row || row.durationSeconds === durationSeconds) return;
+    if (!row || row.durationSeconds === durationSeconds) return null;
     row.durationSeconds = durationSeconds;
-    writeIndex(assets);
+    return assets;
   });
   entry.durationSeconds = durationSeconds;
 }
@@ -406,15 +427,14 @@ function openWithOs(path) {
 export function deleteMediaAsset(id) {
   ensureDirs();
   let removed = false;
-  withFileLockSync(indexLockPath(), () => {
-    const assets = readIndex();
+  mutateIndex((assets) => {
     const entry = assets.find((row) => row.id === id);
-    if (!entry) return;
+    if (!entry) return null;
     const path = storedAssetPath(entry.file);
     try { if (path) unlinkSync(path); } catch {}
     removeRenditions(renditionsDir(), id);
-    writeIndex(assets.filter((row) => row.id !== id));
     removed = true;
+    return assets.filter((row) => row.id !== id);
   });
   return { id, removed };
 }

package/src/runtime/memory/index.mjs

@@ -65,7 +65,7 @@ import { retrieveEntries } from './lib/memory-retrievers.mjs'
 import { pruneOldEntries } from './lib/memory-maintenance-store.mjs'
 import { computeEntryScore } from './lib/memory-score.mjs'
 import { runFullBackfill } from './lib/memory-ops-policy.mjs'
-import { listCore, addCore, editCore, deleteCore, compactCoreIds, listCoreCandidates, promoteCoreCandidate, dismissCoreCandidate } from './lib/core-memory-store.mjs'
+import { listCore, addCore, editCore, deleteCore, listCoreCandidates, promoteCoreCandidate, dismissCoreCandidate } from './lib/core-memory-store.mjs'
 import { refreshCoreMemoryFile } from './lib/core-memory-file.mjs'
 import { resolveProjectId, resolveProjectScope } from './lib/project-id-resolver.mjs'
 import { openTraceDatabase, closeTraceDatabase, insertTraceEvents, enqueueTraceEvents, insertAgentCalls, registerTraceExitDrain } from './lib/trace-store.mjs'
@@ -275,6 +275,7 @@ async function _initStore() {
     provider: embeddingConfig?.provider ?? null,
     model: getEmbeddingModelId(),
     dtype: getEmbeddingDtype(),
+    format: 'mixdog-embedding-v2',
   }
   let dimsResolved = null
   try {
@@ -300,7 +301,7 @@ async function _initStore() {
     // model and the ~560 MB Kiwi analyzer completely off the boot path; the
     // first relevant query starts them on demand without blocking startup.
     const openStartedAt = performance.now()
-    db = await openDatabase(DATA_DIR, dimsResolved)
+    db = await openDatabase(DATA_DIR, dimsResolved, metaKey)
     memoryProfile('open-db:done', { ms: (performance.now() - openStartedAt).toFixed(1), dims: dimsResolved })
   } else {
     if (!embeddingWarmupCanStart()) {
@@ -314,7 +315,7 @@ async function _initStore() {
     dimsResolved = Number(getEmbeddingDims())
     assertSecondaryPgAttachable()
     const openStartedAt = performance.now()
-    db = await openDatabase(DATA_DIR, dimsResolved)
+    db = await openDatabase(DATA_DIR, dimsResolved, metaKey)
     memoryProfile('open-db:done', { ms: (performance.now() - openStartedAt).toFixed(1), dims: dimsResolved })
     try {
       writeJsonAtomicSync(EMBEDDING_META_PATH, { ...metaKey, dims: dimsResolved }, { lock: true })
@@ -451,12 +452,6 @@ async function _initRuntime() {
   memoryProfile('runtime-init:start')
   await _initStore()
   memoryProfile('runtime-init:init-store-ready', { ms: (performance.now() - runtimeStartedAt).toFixed(1) })
-  // Restore the core_entries.id == 1..N invariant once per boot: SERIAL only
-  // increments, so deleted rows leave permanent gaps. Fast no-op when already
-  // contiguous (or empty). Runs only here — never in cycle2/addCore/deleteCore.
-  const compactStartedAt = performance.now()
-  await compactCoreIds(DATA_DIR)
-  memoryProfile('core-ids:compact:done', { ms: (performance.now() - compactStartedAt).toFixed(1) })
   // First boot migrates existing PG core data; later boots reconcile any
   // crash window between a committed PG mutation and its atomic file refresh.
   // The snapshot is not part of memory readiness.

package/src/runtime/memory/lib/agent-ipc.mjs

@@ -10,6 +10,7 @@ import http from 'node:http'
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { resolveRuntimeRoot } from '../../shared/runtime-root.mjs'
+import { isPidAlive } from '../../shared/pid-liveness.mjs'
 
 const brokerAgent = new http.Agent({
   keepAlive: true,
@@ -27,12 +28,6 @@ function runtimeRoot() {
   return resolveRuntimeRoot()
 }
 
-function isPidAlive(value) {
-  const pid = Number(value)
-  if (!Number.isInteger(pid) || pid <= 0) return false
-  try { process.kill(pid, 0); return true } catch (error) { return error?.code === 'EPERM' }
-}
-
 function readBrokerDiscovery() {
   try {
     const raw = JSON.parse(readFileSync(join(runtimeRoot(), 'daemon.json'), 'utf8'))

package/src/runtime/memory/lib/archive-security.test.mjs

@@ -6,11 +6,31 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { gzipSync } from 'node:zlib'
 
-import { _extractTar, _verifyKiwiModelArchive } from './ko-morph.mjs'
+import {
+  _extractTar,
+  _kiwiBuildArgs,
+  _resolveKoMorphIdleTimeout,
+  _verifyKiwiModelArchive,
+} from './ko-morph.mjs'
 import { _validateRuntimeTarEntries } from './runtime-fetcher.mjs'
 
 const REQUIRED = ['combiningRule.txt', 'default.dict', 'extract.mdl', 'sj.knlm', 'sj.morph']
 
+test('Kiwi recall build excludes optional dictionaries and releases after two minutes', () => {
+  const modelFiles = { 'sj.knlm': new Uint8Array([1]) }
+  assert.deepEqual(_kiwiBuildArgs(modelFiles), {
+    modelFiles,
+    modelType: 'knlm',
+    loadDefaultDict: true,
+    loadMultiDict: false,
+    loadTypoDict: false,
+    typos: 'none',
+  })
+  assert.equal(_resolveKoMorphIdleTimeout(undefined), 120_000)
+  assert.equal(_resolveKoMorphIdleTimeout('0'), 0)
+  assert.equal(_resolveKoMorphIdleTimeout('45000'), 45_000)
+})
+
 function tarEntry(name, body = Buffer.alloc(0), type = '0') {
   const bytes = Buffer.from(body)
   const header = Buffer.alloc(512)

package/src/runtime/memory/lib/core-memory-store.mjs

@@ -120,53 +120,11 @@ export async function backfillCoreEmbeddings(dataDir, options = {}) {
   return await _backfillNullEmbeddings(db, options)
 }
 
-// Boot-time invariant restoration: core_entries.id must always be the
-// contiguous sequence 1..N. SERIAL only ever increments, so deleting a row
-// leaves a permanent gap (e.g. 1,2,4,5 after deleting 3). This closes those
-// gaps by resequencing every row globally (across all project_id pools) to
-// 1..N in id order, then realigns the serial so the next INSERT continues from
-// N+1. Deterministic invariant restore — no heuristic, no fallback branch.
-export async function compactCoreIds(dataDir) {
-  const db = _getDb(dataDir)
-  // Fast no-op guard: a contiguous 1..N table has COUNT == MAX(id). This also
-  // covers the empty table (n=0, mx=0) — return before any write.
-  const g = await db.query(`SELECT COUNT(*) AS n, COALESCE(MAX(id),0) AS mx FROM core_entries`)
-  const n = Number(g.rows[0].n)
-  const mx = Number(g.rows[0].mx)
-  if (n === mx) return 0
-
-  // BEGIN transaction on ONE checked-out client — the pool wrapper db.query
-  // releases the client per call, so BEGIN/COMMIT must run on one client
-  // (same pattern as addCore).
-  const client = await checkedConnect(db._pool, 'memory')
-  try {
-    await client.query('BEGIN')
-    // (a) Vacate the low range so shifted ids can't collide with the 1..N
-    // target. Offset by current MAX(id): every id becomes id+mx, which is
-    // strictly greater than N (N <= mx), so the resequence below is safe.
-    await client.query(`UPDATE core_entries SET id = id + $1`, [mx])
-    // (b) Resequence ALL rows globally to 1..N preserving id order.
-    await client.query(`
-      WITH ordered AS (
-        SELECT id, ROW_NUMBER() OVER (ORDER BY id) AS rn FROM core_entries
-      )
-      UPDATE core_entries c SET id = o.rn FROM ordered o WHERE c.id = o.id`)
-    // (c) Realign the serial so the next INSERT continues from N+1. Guarded by
-    // the n===mx return above, so MAX(id) is always > 0 here — setval(...,0,true)
-    // is invalid and is never reached.
-    await client.query(
-      `SELECT setval(pg_get_serial_sequence('core_entries','id'),
-         (SELECT COALESCE(MAX(id),0) FROM core_entries), true)`)
-    await client.query('COMMIT')
-  } catch (err) {
-    try { await client.query('ROLLBACK') } catch {}
-    throw err
-  } finally {
-    client.release()
-  }
-  __mixdogMemoryLog(`[core-memory] compacted ${n} core id(s)\n`)
-  return n
-}
+// NOTE: boot-time core id compaction was REMOVED. Resequencing core_entries.id
+// to 1..N rewrote primary keys that are handed out as stable `core:N`
+// references, so after a restart a retained reference pointed at a different
+// fact. Gaps left by deletes are the correct, permanent behavior of a surrogate
+// key.
 
 async function _findTopKCore(db, projectId, embedding, excludeId, { forUpdate = false } = {}) {
   if (!embedding) return []
@@ -351,10 +309,17 @@ export async function editCore(dataDir, id, patch) {
   const textChanged = newElement !== cur.element || newSummary !== cur.summary
   const projectChanged = newProjectId !== (cur.project_id ?? null)
   if (!textChanged && !projectChanged) {
-    await db.query(
-      `UPDATE core_entries SET category = $1, updated_at = $2 WHERE id = $3`,
-      [newCategory, now, numId],
+    // Optimistic guard on the snapshot this patch was computed against: a blind
+    // UPDATE by id overwrote whatever a concurrent edit had just written.
+    const res = await db.query(
+      `UPDATE core_entries SET category = $1, updated_at = $2
+       WHERE id = $3 AND element = $4 AND summary = $5
+         AND updated_at IS NOT DISTINCT FROM $6::bigint`,
+      [newCategory, now, numId, cur.element, cur.summary, cur.updated_at],
     )
+    if (Number(res.rowCount ?? 0) === 0) {
+      throw new Error(`core entry id=${numId} changed concurrently — re-read and retry`)
+    }
     return { ...cur, element: newElement, summary: newSummary, category: newCategory, updated_at: now }
   }
 
@@ -371,6 +336,19 @@ export async function editCore(dataDir, id, patch) {
     for (const poolKey of new Set(poolKeys)) {
       await client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [poolKey])
     }
+    // Revalidate under the lock. `cur` (and the embedding derived from it) was
+    // read before any locking, so without this check two concurrent edits both
+    // computed a patch from the same snapshot and the slower one silently
+    // overwrote the newer content.
+    const fresh = (await client.query(`SELECT * FROM core_entries WHERE id = $1 FOR UPDATE`, [numId])).rows[0]
+    if (!fresh) throw new Error(`no entry with id=${numId}`)
+    if (fresh.element !== cur.element
+        || fresh.summary !== cur.summary
+        || fresh.category !== cur.category
+        || (fresh.project_id ?? null) !== (cur.project_id ?? null)
+        || Number(fresh.updated_at ?? 0) !== Number(cur.updated_at ?? 0)) {
+      throw new Error(`core entry id=${numId} changed concurrently — re-read and retry`)
+    }
     const candidates = await _findTopKCore(client, newProjectId, embedding, numId, { forUpdate: true })
     const mergeTarget = await _resolveMergeTarget(candidates, { element: newElement, summary: newSummary })
     if (mergeTarget) {

package/src/runtime/memory/lib/embedding-model-config.mjs

@@ -1,17 +1,34 @@
-const DEFAULT_MODEL_ID = 'ibm-granite/granite-embedding-97m-multilingual-r2'
+const DEFAULT_MODEL_ID = 'onnx-community/harrier-oss-v1-270m-ONNX'
+const HARRIER_QUERY_PREFIX = 'Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery: '
 
 const MODEL_PROFILES = Object.freeze({
   [DEFAULT_MODEL_ID]: Object.freeze({
+    dims: 640,
+    defaultDtype: 'q4',
+    defaultDevice: 'cpu',
+    modelFileName: 'model',
+    outputName: 'sentence_embedding',
+    pooling: 'last_token',
+    queryPrefix: HARRIER_QUERY_PREFIX,
+    supportedDtypes: Object.freeze(['fp32', 'fp16', 'q8', 'q4']),
+  }),
+  'ibm-granite/granite-embedding-97m-multilingual-r2': Object.freeze({
     dims: 384,
     defaultDtype: 'fp32',
     defaultDevice: 'cpu',
     modelFileName: 'model_quint8_avx2',
+    outputName: '',
+    pooling: 'mean',
+    queryPrefix: '',
     supportedDtypes: Object.freeze(['fp32']),
   }),
   'Xenova/bge-m3': Object.freeze({
     dims: 1024,
     defaultDtype: 'q4',
     defaultDevice: 'auto',
+    outputName: '',
+    pooling: 'mean',
+    queryPrefix: '',
     supportedDtypes: Object.freeze(['fp32', 'fp16', 'q8', 'q4']),
   }),
 })
@@ -53,3 +70,22 @@ export function getEmbeddingModelLoadOptions(modelId = getConfiguredEmbeddingMod
   const profile = getEmbeddingModelProfile(modelId)
   return profile?.modelFileName ? { model_file_name: profile.modelFileName } : {}
 }
+
+export function getEmbeddingPooling(modelId = getConfiguredEmbeddingModelId()) {
+  return getEmbeddingModelProfile(modelId)?.pooling || 'mean'
+}
+
+export function getEmbeddingOutputName(modelId = getConfiguredEmbeddingModelId()) {
+  return getEmbeddingModelProfile(modelId)?.outputName || ''
+}
+
+export function normalizeEmbeddingInputType(inputType) {
+  return clean(inputType).toLowerCase() === 'query' ? 'query' : 'document'
+}
+
+export function prepareEmbeddingInput(text, inputType = 'document', modelId = getConfiguredEmbeddingModelId()) {
+  const cleanText = clean(text)
+  if (!cleanText || normalizeEmbeddingInputType(inputType) !== 'query') return cleanText
+  const prefix = getEmbeddingModelProfile(modelId)?.queryPrefix || ''
+  return `${prefix}${cleanText}`
+}

package/src/runtime/memory/lib/embedding-model-config.test.mjs

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+  getEmbeddingModelLoadOptions,
+  getEmbeddingOutputName,
+  getEmbeddingPooling,
+  getKnownEmbeddingDims,
+  normalizeEmbeddingDtype,
+  normalizeEmbeddingInputType,
+  prepareEmbeddingInput,
+} from './embedding-model-config.mjs'
+
+const HARRIER = 'onnx-community/harrier-oss-v1-270m-ONNX'
+
+test('Harrier uses its fixed ONNX profile and last-token pooling', () => {
+  assert.equal(getKnownEmbeddingDims(HARRIER), 640)
+  assert.equal(normalizeEmbeddingDtype(HARRIER, ''), 'q4')
+  assert.deepEqual(getEmbeddingModelLoadOptions(HARRIER), { model_file_name: 'model' })
+  assert.equal(getEmbeddingOutputName(HARRIER), 'sentence_embedding')
+  assert.equal(getEmbeddingPooling(HARRIER), 'last_token')
+})
+
+test('Harrier applies its retrieval instruction only to queries', () => {
+  const text = 'Windows 음성 런타임의 메모리 사용량'
+  assert.equal(normalizeEmbeddingInputType('QUERY'), 'query')
+  assert.equal(normalizeEmbeddingInputType('passage'), 'document')
+  assert.equal(prepareEmbeddingInput(text, 'document', HARRIER), text)
+  assert.equal(
+    prepareEmbeddingInput(text, 'query', HARRIER),
+    `Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery: ${text}`,
+  )
+})

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

@@ -14,6 +14,7 @@ import {
   getDefaultEmbeddingDtype,
   getKnownEmbeddingDims,
   normalizeEmbeddingDtype,
+  normalizeEmbeddingInputType,
 } from './embedding-model-config.mjs'
 
 const MODEL_ID = getConfiguredEmbeddingModelId()
@@ -51,6 +52,10 @@ function getCachedEmbedding(key) {
   return queryEmbeddingCache.get(key)
 }
 
+function embeddingCacheKey(text, inputType) {
+  return `${MODEL_ID}\n${normalizeEmbeddingInputType(inputType)}\n${text}`
+}
+
 function ensureWorker() {
   if (worker) return worker
   const now = Date.now()
@@ -143,20 +148,31 @@ function ensureWorker() {
 }
 
 const EMBED_WORKER_TIMEOUT_MS = 60_000
+const EMBED_WORKER_COLD_TIMEOUT_MS = 180_000
 
-function sendToWorker(action, extra = {}, timeoutMs = EMBED_WORKER_TIMEOUT_MS) {
+function embeddingWorkerTimeout(action) {
+  return !_modelReady && ['warmup', 'embed', 'embed-batch'].includes(action)
+    ? EMBED_WORKER_COLD_TIMEOUT_MS
+    : EMBED_WORKER_TIMEOUT_MS
+}
+
+function sendToWorker(action, extra = {}, timeoutMs = embeddingWorkerTimeout(action)) {
   const w = ensureWorker()
   const id = ++_msgId
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       _pending.delete(id)
       __mixdogMemoryLog(`[embed] worker ${action} timed out — terminating worker\n`)
-      if (worker) {
-        const stuck = worker
+      // Retire the worker this request was actually posted to. Reading the
+      // module-level `worker` here killed whatever worker happened to be
+      // current — after a restart that is a healthy replacement, so one stuck
+      // request cascaded into terminating its successor.
+      if (worker === w) {
         worker = null
+        _modelReady = false
         _restartCount++
-        stuck.terminate().catch(() => {})
       }
+      w.terminate().catch(() => {})
       reject(new Error(`embed worker ${action} timed out after ${timeoutMs}ms`))
     }, timeoutMs)
     _pending.set(id, {
@@ -246,13 +262,18 @@ export function warmupEmbeddingProvider() {
 export async function embedText(text, options = {}) {
   const clean = String(text ?? '').trim()
   if (!clean) return []
-  const cacheKey = `${MODEL_ID}\n${clean}`
+  const inputType = normalizeEmbeddingInputType(options?.inputType)
+  const cacheKey = embeddingCacheKey(clean, inputType)
   const cached = getCachedEmbedding(cacheKey)
   if (cached) return [...cached]
 
   // 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 })
+  const result = await sendToWorker('embed', {
+    text: clean,
+    inputType,
+    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) {
@@ -288,20 +309,21 @@ export async function embedText(text, options = {}) {
  * single or batch path. Worker still serializes the single ONNX run, but
  * one batched run replaces N sequential runs.
  */
-export async function embedTexts(texts) {
+export async function embedTexts(texts, options = {}) {
   if (!Array.isArray(texts)) throw new Error('embedTexts requires an array')
+  const inputType = normalizeEmbeddingInputType(options?.inputType)
   const cleaned = texts.map(t => String(t ?? '').trim())
   const missing = []
   for (const t of cleaned) {
     if (!t) continue
-    const key = `${MODEL_ID}\n${t}`
+    const key = embeddingCacheKey(t, inputType)
     if (!queryEmbeddingCache.has(key)) missing.push(t)
   }
   if (missing.length === 0) return cleaned.map(t => {
     if (!t) return []
-    return [...queryEmbeddingCache.get(`${MODEL_ID}\n${t}`)]
+    return [...queryEmbeddingCache.get(embeddingCacheKey(t, inputType))]
   })
-  const result = await sendToWorker('embed-batch', { texts: missing })
+  const result = await sendToWorker('embed-batch', { texts: missing, inputType })
   if (!result.dims) throw new Error(`embed-batch result missing dims (model=${MODEL_ID})`)
   const resultDims = result.dims
   if (cachedDims && resultDims !== cachedDims) {
@@ -318,12 +340,12 @@ export async function embedTexts(texts) {
     if (!Array.isArray(vec) || vec.length !== cachedDims) {
       throw new Error(`embed-batch vector length mismatch at idx ${i}: expected ${cachedDims}, got ${vec?.length}`)
     }
-    cacheEmbedding(`${MODEL_ID}\n${missing[i]}`, vec)
+    cacheEmbedding(embeddingCacheKey(missing[i], inputType), vec)
   }
   _embedCallCount += missing.length
   return cleaned.map(t => {
     if (!t) return []
-    const cached = queryEmbeddingCache.get(`${MODEL_ID}\n${t}`)
+    const cached = queryEmbeddingCache.get(embeddingCacheKey(t, inputType))
     return cached ? [...cached] : []
   })
 }

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

@@ -13,7 +13,11 @@ import {
   getDefaultEmbeddingDevice,
   getDefaultEmbeddingDtype,
   getEmbeddingModelLoadOptions,
+  getEmbeddingOutputName,
+  getEmbeddingPooling,
   normalizeEmbeddingDtype,
+  normalizeEmbeddingInputType,
+  prepareEmbeddingInput,
 } from './embedding-model-config.mjs'
 
 const MODEL_ID = getConfiguredEmbeddingModelId()
@@ -40,6 +44,7 @@ process.stderr.write = __forwardWorkerWrite
 const DEFAULT_DEVICE = getDefaultEmbeddingDevice(MODEL_ID)
 const DEFAULT_DTYPE = getDefaultEmbeddingDtype(MODEL_ID)
 const MODEL_LOAD_OPTIONS = getEmbeddingModelLoadOptions(MODEL_ID)
+const MODEL_OUTPUT_NAME = getEmbeddingOutputName(MODEL_ID)
 const INTRA_OP_THREADS = 1
 const INTER_OP_THREADS = 1
 // Session-create graph optimization. ORT defaults to 'all' (full node fusion),
@@ -77,12 +82,16 @@ const _envWorkerMaxChars = Number(process.env.MIXDOG_EMBED_MAX_CHARS)
 const WORKER_MAX_CHARS = (Number.isFinite(_envWorkerMaxChars) && _envWorkerMaxChars > 0)
   ? Math.floor(_envWorkerMaxChars)
   : 8000
-const EXTRACT_OPTS = { pooling: 'mean', normalize: true, truncation: true }
+const EXTRACT_OPTS = { pooling: getEmbeddingPooling(MODEL_ID), normalize: true, truncation: true }
 function capEmbedText(text) {
   if (typeof text !== 'string') return ''
   return text.length > WORKER_MAX_CHARS ? text.slice(0, WORKER_MAX_CHARS) : text
 }
 
+function prepareWorkerText(text, inputType) {
+  return capEmbedText(prepareEmbeddingInput(text, inputType, MODEL_ID))
+}
+
 let extractorPromise = null
 let configuredDtype = DEFAULT_DTYPE
 let _device = 'cpu'
@@ -244,7 +253,7 @@ async function loadExtractor() {
     extractorPromise = (async () => {
       parentPort.postMessage({ type: 'profile', record: { phase: 'baseline', model: MODEL_ID, device: _device, dtype: configuredDtype, note: 'pre-load' } })
       patchOrtThreads()
-      const { pipeline, env } = await import('@huggingface/transformers')
+      const { AutoModel, AutoTokenizer, pipeline, env } = await import('@huggingface/transformers')
       try { env.backends.onnx.logLevel = 'fatal' } catch {}
       env.allowLocalModels = false
       try { mkdirSync(MODEL_CACHE_DIR, { recursive: true }) } catch {}
@@ -277,7 +286,28 @@ async function loadExtractor() {
       let priorityLowered = false
       try { os.setPriority(0, os.constants.priority.PRIORITY_BELOW_NORMAL); priorityLowered = true } catch {}
       try {
-        if (preferGpu) {
+        if (MODEL_OUTPUT_NAME) {
+          const device = preferGpu ? 'dml' : 'cpu'
+          const [tokenizer, model] = await Promise.all([
+            AutoTokenizer.from_pretrained(MODEL_ID),
+            AutoModel.from_pretrained(MODEL_ID, { ...opts, device }),
+          ])
+          extractor = async (input, extractOptions = {}) => {
+            const modelInputs = await tokenizer(input, {
+              padding: true,
+              truncation: extractOptions.truncation !== false,
+            })
+            const outputs = await model(modelInputs)
+            let result = outputs?.[MODEL_OUTPUT_NAME]
+            if (!result?.data?.length) {
+              throw new Error(`embedding output '${MODEL_OUTPUT_NAME}' missing (model=${MODEL_ID})`)
+            }
+            if (extractOptions.normalize) result = result.normalize(2, -1)
+            return result
+          }
+          extractor.dispose = () => model.dispose()
+          _device = device
+        } else if (preferGpu) {
           extractor = await pipeline('feature-extraction', MODEL_ID, { ...opts, device: 'dml' })
           _device = 'dml'
         } else {
@@ -334,7 +364,8 @@ async function processMessage(msg) {
           break
         }
         const t0 = Date.now()
-        const output = await extractor(texts.map(capEmbedText), EXTRACT_OPTS)
+        const inputType = normalizeEmbeddingInputType(msg.inputType)
+        const output = await extractor(texts.map((text) => prepareWorkerText(text, inputType)), EXTRACT_OPTS)
         const wallMs = Date.now() - t0
         if (!output.data?.length) throw new Error(`embed-batch output missing data (model=${MODEL_ID})`)
         const total = output.data.length
@@ -356,7 +387,8 @@ async function processMessage(msg) {
         resetIdleTimer()
         const extractor = await loadExtractor()
         const t0 = Date.now()
-        const output = await extractor(capEmbedText(msg.text), EXTRACT_OPTS)
+        const inputType = normalizeEmbeddingInputType(msg.inputType)
+        const output = await extractor(prepareWorkerText(msg.text, inputType), EXTRACT_OPTS)
         const wallMs = Date.now() - t0
         if (!output.data?.length) throw new Error(`embed output missing data (model=${MODEL_ID})`)
         const dims = output.data.length