@qvac/sdk 0.15.0 → 0.17.0

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-session.js

@@ -1,54 +1,27 @@
 import { promises as fsPromises } from 'bare-fs';
 import path from 'bare-path';
-import { findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, renameCacheFile, deleteCache as deleteCacheUtil } from '../../../ops/kv-cache-utils.js';
-import { logCacheSaveError, logCacheStatus } from './cache-logger.js';
+import { findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, pruneEmptyCacheDirectories, renameCacheFile, deleteCache as deleteCacheUtil } from '../../../../../server/bare/ops/kv-cache-utils.js';
+import { isCachePathWithinDirectory, markAutoCacheKey, planAutoCacheEvictions, removeAutoCacheMarker, removeAutoCacheMarkerIfMissing } from '../../../../../server/bare/ops/kv-cache-retention.js';
+import { isMobile } from '../../../../../server/bare/registry/runtime-context-registry.js';
+import { getKVCacheDir } from '../../../../../server/utils/index.js';
+import { logCacheSaveError, logCacheStatus } from '../../../../../server/bare/plugins/llamacpp-completion/ops/cache-logger.js';
 import { getServerLogger } from '../../../../../logging/index.js';
 // Used by cross-model paths that have no `RequestContext` (e.g.
 // `deleteKvCacheState`). Per-session call sites receive a logger from
 // the caller — typically `withRequestContext(...)`.
 const moduleLogger = getServerLogger();
 /**
- * Single owner of the three KV-cache bookkeeping layers.
+ * Coordinates five KV-cache state layers:
  *
- * The llama.cpp completion handler has three independent layers it must
- * keep consistent across every cancel/error branch:
+ * 1. `cachedMessageCounts` — saved message boundaries.
+ * 2. `initializedCaches` — caches primed in this worker.
+ * 3. On-disk `.bin` files written by the addon.
+ * 4. `activeCachePaths` — per-path refs that block in-flight eviction.
+ * 5. `.auto-cache-<key>` markers — SDK-generated cache ownership.
  *
- *   1. `cachedMessageCounts: Map<path, count>` — the "n messages
- *      currently on disk" tracker.
- *   2. `initializedCaches: Set<key>` — the "addon defers disk writes;
- *      we know this cache is primed" tracker.
- *   3. On-disk `.bin` files written by the addon.
- *
- * Without a single owner, every cancel / zero-token / rename-failed /
- * tool-call exit would need to touch all three; any branch that forgets
- * a layer produces three-layer drift bugs.
- *
- * `KvCacheSession` collapses the three layers behind one object with
- * three operations:
- *
- *   - `beginTurn` — resolves the cache file path, primes the system
- *     prompt cache if missing (delegated to a caller-supplied closure
- *     so the session doesn't depend on the model addon), marks the
- *     cache initialized, and returns a `TurnHandle` carrying the
- *     resolved path + the snapshot of the on-disk saved count.
- *   - `commitTurn` — records the new saved count (for custom-key
- *     turns) or renames the addon's pre-response file to the
- *     post-response path and records the count there (for auto-cache
- *     turns). Flips the turn's internal `committed` flag so the
- *     deferred `rollback` becomes a no-op on the happy path.
- *   - `rollback` — atomically deletes the on-disk file, clears the
- *     in-memory init entry, and forgets the saved count. **All three
- *     layers, always, in one place.** Handlers call it once via
- *     `ctx.scope.defer(() => session.rollback(turn))`; `commitTurn`
- *     short-circuits it on success.
- *
- * The module-level `deleteKvCacheState(...)` function (below) provides
- * an administrative cross-model delete API for the
- * `handleDeleteCache` RPC handler.
- *
- * The module-scoped `cachedMessageCounts` and `initializedCaches` maps
- * are *private* to this file — no other module reaches into them.
- * Callers that need cache-status info do so through the session API.
+ * Every turn must finish through `commitTurn` or `rollback` so all
+ * inference state stays aligned, the active-path ref is released, and
+ * marker metadata follows the cache directory lifecycle.
  */
 // ----- module-scoped state. The session is the single mutation point
 // for the in-memory KV-cache bookkeeping. -----
@@ -70,9 +43,101 @@ const cachedMessageCounts = new Map();
  * older worker runs still hit the lazy-load path in `beginTurn`.
  */
 const initializedCaches = new Set();
+const activeCachePaths = new Map();
+const DESKTOP_AUTO_CACHE_MAX_BYTES = 4 * 1024 * 1024 * 1024;
+const MOBILE_AUTO_CACHE_MAX_BYTES = 512 * 1024 * 1024;
+const AUTO_CACHE_MAX_IDLE_MS = 24 * 60 * 60 * 1000;
+const AUTO_CACHE_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+let lastAutoCacheSweepMs = 0;
+let autoCacheSweepInFlight = null;
+let cacheStateLockTail = Promise.resolve();
 function initRegistryKey(modelId, configHash, cacheKey) {
     return `${modelId}:${configHash}:${cacheKey}`;
 }
+function markCachePathActive(cachePath) {
+    activeCachePaths.set(cachePath, (activeCachePaths.get(cachePath) ?? 0) + 1);
+}
+function releaseCachePath(cachePath) {
+    const count = activeCachePaths.get(cachePath);
+    if (count === undefined)
+        return;
+    if (count === 1) {
+        activeCachePaths.delete(cachePath);
+        return;
+    }
+    activeCachePaths.set(cachePath, count - 1);
+}
+function isCacheKeyActive(cacheKey) {
+    const cacheDirectory = path.join(getKVCacheDir(), cacheKey);
+    return Array.from(activeCachePaths.keys()).some((cachePath) => isCachePathWithinDirectory(cacheDirectory, cachePath));
+}
+function getAutoCacheMaxBytes() {
+    return isMobile() ? MOBILE_AUTO_CACHE_MAX_BYTES : DESKTOP_AUTO_CACHE_MAX_BYTES;
+}
+async function withCacheStateLock(operation) {
+    const previous = cacheStateLockTail;
+    let releaseLock = () => { };
+    cacheStateLockTail = new Promise((resolve) => {
+        releaseLock = resolve;
+    });
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        releaseLock();
+    }
+}
+async function maybeSweepAutoCaches(logger, overrides) {
+    const nowMs = overrides?.nowMs ?? Date.now();
+    if (autoCacheSweepInFlight !== null) {
+        await autoCacheSweepInFlight;
+        if (!overrides?.force)
+            return;
+        return maybeSweepAutoCaches(logger, overrides);
+    }
+    if (!overrides?.force && nowMs - lastAutoCacheSweepMs < AUTO_CACHE_SWEEP_INTERVAL_MS)
+        return;
+    lastAutoCacheSweepMs = nowMs;
+    const sweep = async () => {
+        try {
+            const cacheKeys = await planAutoCacheEvictions({
+                activeCachePaths: Array.from(activeCachePaths.keys()),
+                maxBytes: overrides?.maxBytes ?? getAutoCacheMaxBytes(),
+                maxIdleMs: overrides?.maxIdleMs ?? AUTO_CACHE_MAX_IDLE_MS,
+                nowMs
+            });
+            let evictionCount = 0;
+            await withCacheStateLock(async () => {
+                for (const cacheKey of cacheKeys) {
+                    if (isCacheKeyActive(cacheKey))
+                        continue;
+                    await deleteKvCacheState({ kvCacheKey: cacheKey });
+                    evictionCount++;
+                }
+            });
+            if (evictionCount > 0) {
+                logger.debug(`[kv-cache] Evicted ${evictionCount} inactive auto-cache entries`);
+            }
+        }
+        catch (error) {
+            logger.warn(`[kv-cache] Auto-cache retention sweep failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    };
+    const sweepPromise = sweep();
+    autoCacheSweepInFlight = sweepPromise;
+    try {
+        await sweepPromise;
+    }
+    finally {
+        autoCacheSweepInFlight = null;
+    }
+}
+function scheduleAutoCacheSweep(logger) {
+    void maybeSweepAutoCaches(logger).catch((error) => {
+        logger.warn(`[kv-cache] Failed to schedule auto-cache retention sweep: ${error instanceof Error ? error.message : String(error)}`);
+    });
+}
 // ----- factory -----
 /**
  * Construct a session bound to one `(modelId, turn-owning request)`
@@ -86,7 +151,7 @@ export function createKvCacheSession(modelId, options) {
     // WeakMap so handles drop their state once the handler scope releases
     // the reference; the module-scoped maps above survive.
     const turnState = new WeakMap();
-    function makeHandle(cachePath, registryKey) {
+    function makeHandle(cachePath, registryKey, autoCacheKey) {
         const handle = {
             cachePath,
             savedCount: cachedMessageCounts.get(cachePath) ?? 0
@@ -94,36 +159,45 @@ export function createKvCacheSession(modelId, options) {
         turnState.set(handle, {
             cachePath,
             registryKey,
+            ...(autoCacheKey !== undefined && { autoCacheKey }),
             committed: false,
             rolledBack: false
         });
+        markCachePathActive(cachePath);
         return handle;
     }
     async function beginCustom(input) {
         const cachePath = await getCacheFilePath(modelId, input.configHash, input.customKey);
         const registryKey = initRegistryKey(modelId, input.configHash, input.customKey);
-        // In-memory registry check first — the addon defers disk writes, so
-        // a freshly-primed cache may not yet exist on disk. If the
-        // in-memory flag isn't set, fall back to a filesystem probe so
-        // caches surviving across worker restarts still hit the reuse path.
-        let exists = initializedCaches.has(registryKey);
-        if (!exists) {
-            try {
-                await fsPromises.access(cachePath);
-                exists = true;
-                initializedCaches.add(registryKey);
+        const handle = makeHandle(cachePath, registryKey);
+        try {
+            // In-memory registry check first — the addon defers disk writes, so
+            // a freshly-primed cache may not yet exist on disk. If the
+            // in-memory flag isn't set, fall back to a filesystem probe so
+            // caches surviving across worker restarts still hit the reuse path.
+            let exists = initializedCaches.has(registryKey);
+            if (!exists) {
+                try {
+                    await fsPromises.access(cachePath);
+                    exists = true;
+                    initializedCaches.add(registryKey);
+                }
+                catch {
+                    exists = false;
+                }
             }
-            catch {
-                exists = false;
+            logCacheStatus(input.customKey, exists);
+            if (!exists) {
+                await input.primeIfMissing(cachePath);
+                await verifyPrimedFile(cachePath, logger);
+                initializedCaches.add(registryKey);
             }
+            return handle;
         }
-        logCacheStatus(input.customKey, exists);
-        if (!exists) {
-            await input.primeIfMissing(cachePath);
-            await verifyPrimedFile(cachePath, logger);
-            initializedCaches.add(registryKey);
+        catch (error) {
+            releaseCachePath(cachePath);
+            throw error;
         }
-        return makeHandle(cachePath, registryKey);
     }
     async function beginAuto(input) {
         // The pre-response cache key is derived from
@@ -131,19 +205,34 @@ export function createKvCacheSession(modelId, options) {
         // internally. The post-response key (used after a successful turn)
         // is computed by the caller and passed to `commitTurn` as
         // `targetCachePath`.
-        const existingCache = await findMatchingCache(modelId, input.configHash, input.history);
-        const preResponseCacheInfo = await getCurrentCacheInfo(modelId, input.configHash, input.history);
-        const cachePath = existingCache !== null ? existingCache.cachePath : preResponseCacheInfo.cachePath;
-        const cacheKeyForRegistry = existingCache !== null ? existingCache.cacheKey : preResponseCacheInfo.cacheKey;
-        const registryKey = initRegistryKey(modelId, input.configHash, cacheKeyForRegistry);
-        const cacheExists = existingCache !== null;
+        const setup = await withCacheStateLock(async () => {
+            const existingCache = await findMatchingCache(modelId, input.configHash, input.history);
+            const cacheInfo = existingCache ?? (await getCurrentCacheInfo(modelId, input.configHash, input.history));
+            const registryKey = initRegistryKey(modelId, input.configHash, cacheInfo.cacheKey);
+            return {
+                cacheExists: existingCache !== null,
+                cachePath: cacheInfo.cachePath,
+                cacheKey: cacheInfo.cacheKey,
+                registryKey,
+                handle: makeHandle(cacheInfo.cachePath, registryKey, cacheInfo.cacheKey)
+            };
+        });
+        const { cacheExists, cachePath, cacheKey, registryKey, handle } = setup;
         logCacheStatus('auto', cacheExists);
-        if (!cacheExists) {
-            await input.primeIfMissing(cachePath);
-            await verifyPrimedFile(cachePath, logger);
-            initializedCaches.add(registryKey);
+        try {
+            if (!cacheExists) {
+                await input.primeIfMissing(cachePath);
+                await verifyPrimedFile(cachePath, logger);
+                initializedCaches.add(registryKey);
+            }
+            return handle;
+        }
+        catch (error) {
+            releaseCachePath(cachePath);
+            await pruneEmptyCacheDirectories(cachePath);
+            await removeAutoCacheMarkerIfMissing(cacheKey);
+            throw error;
         }
-        return makeHandle(cachePath, registryKey);
     }
     async function beginTurn(input) {
         if (input.kind === 'custom')
@@ -174,24 +263,42 @@ export function createKvCacheSession(modelId, options) {
                 return;
             }
             state.committed = true;
+            releaseCachePath(state.cachePath);
             return;
         }
-        // Auto-rename path: the pre-response file is now stale (its key
-        // refers to history minus the last user turn). Rename it to the
-        // post-response key and record the new count there.
-        if (!(await renameCacheFile(state.cachePath, result.targetCachePath))) {
-            logger.warn(`[kv-cache] Auto cache rename failed; rolling back. from=${state.cachePath} to=${result.targetCachePath}`);
+        const sourceCachePath = state.cachePath;
+        const sourceCacheKey = state.autoCacheKey;
+        const targetCacheKey = path.basename(path.dirname(path.dirname(result.targetCachePath)));
+        const renamed = await withCacheStateLock(async () => {
+            markCachePathActive(result.targetCachePath);
+            await fsPromises.mkdir(path.dirname(result.targetCachePath), { recursive: true });
+            await markAutoCacheKey(targetCacheKey);
+            if (!(await renameCacheFile(sourceCachePath, result.targetCachePath))) {
+                releaseCachePath(result.targetCachePath);
+                await pruneEmptyCacheDirectories(result.targetCachePath);
+                await removeAutoCacheMarkerIfMissing(targetCacheKey);
+                return false;
+            }
+            releaseCachePath(sourceCachePath);
+            state.cachePath = result.targetCachePath;
+            state.autoCacheKey = targetCacheKey;
+            await pruneEmptyCacheDirectories(sourceCachePath);
+            if (sourceCacheKey !== undefined) {
+                await removeAutoCacheMarkerIfMissing(sourceCacheKey);
+            }
+            cachedMessageCounts.delete(sourceCachePath);
+            initializedCaches.delete(state.registryKey);
+            return true;
+        });
+        if (!renamed) {
+            logger.warn(`[kv-cache] Auto cache rename failed; rolling back. from=${sourceCachePath} to=${result.targetCachePath}`);
             await runRollback(state);
             return;
         }
-        // The source path's entry is gone (the file moved). Drop it and
-        // record the new count at the rename target.
-        cachedMessageCounts.delete(state.cachePath);
         const ok = await verifySaveAndRecord(result.targetCachePath, result.messageCount);
         if (!ok) {
             // Rename succeeded but the file isn't where we expected. Roll
             // back via the target path instead of the (now-empty) source.
-            state.cachePath = result.targetCachePath;
             await runRollback(state);
             return;
         }
@@ -200,6 +307,8 @@ export function createKvCacheSession(modelId, options) {
         // is committed and won't roll back. Future turns compute fresh
         // paths.
         state.committed = true;
+        releaseCachePath(state.cachePath);
+        scheduleAutoCacheSweep(logger);
     }
     async function rollback(turn) {
         const state = turnState.get(turn);
@@ -220,9 +329,16 @@ export function createKvCacheSession(modelId, options) {
         catch (unlinkError) {
             logger.warn(`[kv-cache] Failed to remove cache file during rollback; next turn may load stale KV state. path=${state.cachePath} error=${unlinkError instanceof Error ? unlinkError.message : String(unlinkError)}`);
         }
+        await pruneEmptyCacheDirectories(state.cachePath);
+        if (state.autoCacheKey !== undefined) {
+            await removeAutoCacheMarkerIfMissing(state.autoCacheKey);
+        }
         initializedCaches.delete(state.registryKey);
         cachedMessageCounts.delete(state.cachePath);
+        releaseCachePath(state.cachePath);
         state.rolledBack = true;
+        if (state.autoCacheKey !== undefined)
+            scheduleAutoCacheSweep(logger);
     }
     function dropStaleSavedCount(turn) {
         const state = turnState.get(turn);
@@ -282,6 +398,9 @@ export async function deleteKvCacheState(target) {
         kvCacheKey: target.kvCacheKey,
         ...(target.modelId !== undefined && { modelId: target.modelId })
     });
+    if (target.modelId === undefined) {
+        await removeAutoCacheMarker(target.kvCacheKey);
+    }
     // Prefix-cleanup the in-memory counts. The on-disk directory tree
     // is `{kvCacheRoot}/{kvCacheKey}[/{modelId}]/`, so every entry in
     // `cachedMessageCounts` whose key is the removed directory itself
@@ -335,6 +454,7 @@ async function verifyPrimedFile(cachePath, logger) {
     catch (statError) {
         // ENOENT is the common case here — addon prime returned without
         // calling save (most often: signal abort during prefill).
+        await pruneEmptyCacheDirectories(cachePath);
         throw new Error(`[kv-cache] prime closure resolved but no cache file was written. path=${cachePath} cause=${statError instanceof Error ? statError.message : String(statError)}`);
     }
     if (stats.size === 0) {
@@ -343,6 +463,7 @@ async function verifyPrimedFile(cachePath, logger) {
         // primary "prime didn't persist" condition.
         try {
             await fsPromises.unlink(cachePath);
+            await pruneEmptyCacheDirectories(cachePath);
         }
         catch (unlinkError) {
             logger.warn(`[kv-cache] Failed to remove empty primed cache file. path=${cachePath} error=${unlinkError instanceof Error ? unlinkError.message : String(unlinkError)}`);
@@ -432,9 +553,25 @@ export const __kvCacheSessionTestHooks = {
     markInitializedForTest(modelId, configHash, cacheKey) {
         initializedCaches.add(initRegistryKey(modelId, configHash, cacheKey));
     },
+    getLastAutoCacheSweepMsForTest() {
+        return lastAutoCacheSweepMs;
+    },
+    setLastAutoCacheSweepMsForTest(value) {
+        lastAutoCacheSweepMs = value;
+    },
     resetForTest() {
         cachedMessageCounts.clear();
         initializedCaches.clear();
+        activeCachePaths.clear();
+        lastAutoCacheSweepMs = 0;
+        autoCacheSweepInFlight = null;
+        cacheStateLockTail = Promise.resolve();
+    },
+    waitForAutoCacheSweepForTest() {
+        return autoCacheSweepInFlight ?? Promise.resolve();
+    },
+    sweepAutoCachesForTest(options) {
+        return maybeSweepAutoCaches(moduleLogger, { ...options, force: true });
     }
 };
 // Re-export `generateConfigHash` from the path utilities so callers of

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-state.d.ts

@@ -32,6 +32,13 @@ export interface HistorySliceDecision {
      */
     clearStaleCount: boolean;
 }
+interface CacheCommitContext {
+    aborted: boolean;
+    producedTokens: boolean;
+    generatedTokens?: number | undefined;
+    predict?: number | undefined;
+}
+export declare function shouldCommitCachedTurn(context: CacheCommitContext): boolean;
 /**
  * Pure slice decision for `prepareMessagesForCache`.
  *
@@ -46,4 +53,5 @@ export interface HistorySliceDecision {
  * than handing the model an empty payload.
  */
 export declare function decideCachedHistorySlice(savedCount: number, cacheExists: boolean, history: HistoryMessage[]): HistorySliceDecision;
+export {};
 //# sourceMappingURL=kv-cache-state.d.ts.map

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-state.js

@@ -14,6 +14,14 @@
  * layers (saved counts, init flags, on-disk files). Only the pure
  * slice-decision helper remains here.
  */
+export function shouldCommitCachedTurn(context) {
+    const { aborted, producedTokens, generatedTokens, predict } = context;
+    const stoppedByBudget = predict !== undefined &&
+        predict > 0 &&
+        generatedTokens !== undefined &&
+        generatedTokens >= predict;
+    return !aborted && producedTokens && !stoppedByBudget;
+}
 /**
  * Pure slice decision for `prepareMessagesForCache`.
  *

package/dist/server/bare/plugins/llamacpp-completion/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type LlmConfigInput } from '../../../../schemas/index';
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type LlmConfigInput } from '../../../../schemas/index.js';
 export declare const llmPlugin: {
     modelType: "llamacpp-completion";
     displayName: string;
@@ -15,7 +15,12 @@ export declare const llmPlugin: {
         predict: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<-1>, import("zod").ZodLiteral<-2>, import("zod").ZodNumber]>>;
         system_prompt: import("zod").ZodOptional<import("zod").ZodString>;
         no_mmap: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        verbosity: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<0>, import("zod").ZodLiteral<1>, import("zod").ZodLiteral<2>, import("zod").ZodLiteral<3>]>>;
+        verbosity: import("zod").ZodOptional<import("zod").ZodEnum<{
+            readonly ERROR: 0;
+            readonly WARN: 1;
+            readonly INFO: 2;
+            readonly DEBUG: 3;
+        }>>;
         presence_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
         frequency_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
         repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -55,6 +60,7 @@ export declare const llmPlugin: {
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
                 diffusion: "diffusion";
+                audiogen: "audiogen";
                 tts: "tts";
                 ocr: "ocr";
                 vla: "vla";
@@ -68,6 +74,7 @@ export declare const llmPlugin: {
                 "parakeet-transcription": "parakeet-transcription";
                 "ggml-ocr": "ggml-ocr";
                 "sdcpp-generation": "sdcpp-generation";
+                "audiogen-ggml": "audiogen-ggml";
                 "ggml-vla": "ggml-vla";
                 "ggml-classification": "ggml-classification";
                 llm: "llm";
@@ -156,7 +163,7 @@ export declare const llmPlugin: {
     }>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
-        batchCompletionStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        batchCompletionStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             stream: import("zod").ZodOptional<import("zod").ZodBoolean>;
             captureThinking: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -168,6 +175,7 @@ export declare const llmPlugin: {
                 harmony: "harmony";
                 qwen35: "qwen35";
                 gemma4: "gemma4";
+                dsml: "dsml";
             }>>;
             requestId: import("zod").ZodOptional<import("zod").ZodString>;
             prompts: import("zod").ZodArray<import("zod").ZodObject<{
@@ -220,7 +228,7 @@ export declare const llmPlugin: {
                                 integer: "integer";
                             }>;
                             description: import("zod").ZodOptional<import("zod").ZodString>;
-                            enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull]>>>;
                         }, import("zod/v4/core").$strip>>;
                         required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                     }, import("zod/v4/core").$strip>;
@@ -275,6 +283,7 @@ export declare const llmPlugin: {
                         cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                         promptTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                         generatedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        emittedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                         avgConcurrentSeq: import("zod").ZodOptional<import("zod").ZodNumber>;
                         backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
                             gpu: "gpu";
@@ -311,6 +320,7 @@ export declare const llmPlugin: {
                 cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                 promptTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                 generatedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                emittedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                 avgConcurrentSeq: import("zod").ZodOptional<import("zod").ZodNumber>;
                 backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
                     gpu: "gpu";
@@ -318,7 +328,7 @@ export declare const llmPlugin: {
                 }>>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strict>>;
-        completionStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+        completionStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             history: import("zod").ZodArray<import("zod").ZodObject<{
                 role: import("zod").ZodString;
                 content: import("zod").ZodString;
@@ -343,7 +353,7 @@ export declare const llmPlugin: {
                             integer: "integer";
                         }>;
                         description: import("zod").ZodOptional<import("zod").ZodString>;
-                        enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                        enum: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodNull]>>>;
                     }, import("zod/v4/core").$strip>>;
                     required: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                 }, import("zod/v4/core").$strip>;
@@ -371,6 +381,7 @@ export declare const llmPlugin: {
                 harmony: "harmony";
                 qwen35: "qwen35";
                 gemma4: "gemma4";
+                dsml: "dsml";
             }>>;
             responseFormat: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"text">;
@@ -432,6 +443,7 @@ export declare const llmPlugin: {
                     cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                     promptTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                     generatedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    emittedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                     avgConcurrentSeq: import("zod").ZodOptional<import("zod").ZodNumber>;
                     backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
                         gpu: "gpu";
@@ -462,7 +474,7 @@ export declare const llmPlugin: {
                 }, import("zod/v4/core").$strip>>;
             }, import("zod/v4/core").$strict>]>>;
         }, import("zod/v4/core").$strict>>;
-        finetune: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        finetune: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             options: import("zod").ZodObject<{
                 trainDatasetDir: import("zod").ZodString;
@@ -613,7 +625,7 @@ export declare const llmPlugin: {
                 epochs_completed: import("zod").ZodNumber;
             }, import("zod/v4/core").$strict>>;
         }, import("zod/v4/core").$strict>>;
-        translate: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        translate: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             text: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
             stream: import("zod").ZodBoolean;

package/dist/server/bare/plugins/llamacpp-completion/plugin.js

@@ -51,27 +51,27 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import LlmLlamacpp from '@qvac/llm-llamacpp';
-import llmAddonLogging from '@qvac/llm-llamacpp/addonLogging.js';
+import llmAddonLogging from '@qvac/llm-llamacpp/addonLogging';
 import { definePlugin, defineHandler, finetuneRequestSchema, batchCompletionStreamRequestSchema, batchCompletionStreamResponseSchema, completionStreamRequestSchema, completionStreamResponseSchema, finetuneResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, llmConfigBaseSchema, ADDON_LLM } from '../../../../schemas/index.js';
 import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { expandGGUFIntoShards } from '../../../utils/index.js';
-import { completion } from './ops/completion-stream.js';
-import { batchCompletion } from './ops/batch-completion-stream.js';
-import { finetune } from './ops/finetune.js';
-import { translate } from '../../ops/translate.js';
-import { transformLlmConfig } from './transform.js';
+import { expandGGUFIntoShards } from '../../../../server/utils/index.js';
+import { completion } from '../../../../server/bare/plugins/llamacpp-completion/ops/completion-stream.js';
+import { batchCompletion } from '../../../../server/bare/plugins/llamacpp-completion/ops/batch-completion-stream.js';
+import { finetune } from '../../../../server/bare/plugins/llamacpp-completion/ops/finetune.js';
+import { translate } from '../../../../server/bare/ops/translate.js';
+import { transformLlmConfig } from '../../../../server/bare/plugins/llamacpp-completion/transform.js';
 import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { getModelConfig } from '../../registry/model-registry.js';
-import { createCompletionNormalizer } from '../../../utils/completion-normalizer.js';
-import { detectToolDialect } from '../../../utils/tool-integration.js';
-import { getRequestRegistry, withRequestContext } from '../../runtime/index.js';
-import { generateServerRequestId } from '../../runtime/request-id.js';
+import { getModelConfig } from '../../../../server/bare/registry/model-registry.js';
+import { createCompletionNormalizer } from '../../../../server/utils/completion-normalizer.js';
+import { detectToolDialect } from '../../../../server/utils/tool-integration.js';
+import { getRequestRegistry, withRequestContext } from '../../../../server/bare/runtime/index.js';
+import { generateServerRequestId } from '../../../../server/bare/runtime/request-id.js';
 import { getServerLogger } from '../../../../logging/index.js';
 import { ContextOverflowError } from '../../../../utils/errors-server.js';
-import { isAddonContextOverflowError, parseContextOverflowMessage } from './ops/context-overflow.js';
-import { isAddonCancelledError } from './ops/batch-cancelled.js';
-import { isMobile } from '../../registry/runtime-context-registry.js';
-import { stripMultiGpuKeys } from '../../../utils/multi-gpu-mobile.js';
+import { isAddonContextOverflowError, parseContextOverflowMessage } from '../../../../server/bare/plugins/llamacpp-completion/ops/context-overflow.js';
+import { isAddonCancelledError } from '../../../../server/bare/plugins/llamacpp-completion/ops/batch-cancelled.js';
+import { isMobile } from '../../../../server/bare/registry/runtime-context-registry.js';
+import { stripMultiGpuKeys } from '../../../../server/utils/multi-gpu-mobile.js';
 function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
     const logger = createStreamLogger(modelId, ModelType.llamacppCompletion);
     registerAddonLogger(modelId, ModelType.llamacppCompletion, logger);

package/dist/server/bare/plugins/llamacpp-completion/transform.d.ts

@@ -1,4 +1,4 @@
-import { type LlmConfig } from '../../../../schemas/index';
+import { type LlmConfig } from '../../../../schemas/index.js';
 /**
  * Converts an LlmConfig into the flat string-keyed map the C++ addon expects.
  *