@qvac/sdk 0.17.1 → 0.18.0

package/dist/server/bare/ops/kv-cache-retention.js

@@ -5,10 +5,17 @@ import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 const AUTO_CACHE_MARKER_PREFIX = '.auto-cache-';
 const AUTO_CACHE_MARKER_PATTERN = /^\.auto-cache-([a-f0-9]{16})$/;
+// SDK-generated auto-cache keys are 16 hex chars. Marker ops gate on this so a
+// caller-provided key never gets a marker and the raw-key marker path stays
+// inside the cache root.
+const AUTO_CACHE_KEY_PATTERN = /^[a-f0-9]{16}$/;
 function getAutoCacheMarkerPath(cacheKey) {
     return path.join(getKVCacheDir(), `${AUTO_CACHE_MARKER_PREFIX}${cacheKey}`);
 }
 export async function markAutoCacheKey(cacheKey) {
+    // Only generated 16-hex auto keys get markers (see AUTO_CACHE_KEY_PATTERN).
+    if (!AUTO_CACHE_KEY_PATTERN.test(cacheKey))
+        return;
     try {
         await fsPromises.writeFile(getAutoCacheMarkerPath(cacheKey), '');
     }
@@ -17,6 +24,8 @@ export async function markAutoCacheKey(cacheKey) {
     }
 }
 export async function removeAutoCacheMarker(cacheKey) {
+    if (!AUTO_CACHE_KEY_PATTERN.test(cacheKey))
+        return;
     try {
         await fsPromises.unlink(getAutoCacheMarkerPath(cacheKey));
     }
@@ -25,6 +34,8 @@ export async function removeAutoCacheMarker(cacheKey) {
     }
 }
 export async function removeAutoCacheMarkerIfMissing(cacheKey) {
+    if (!AUTO_CACHE_KEY_PATTERN.test(cacheKey))
+        return;
     try {
         await fsPromises.access(path.join(getKVCacheDir(), cacheKey));
     }

package/dist/server/bare/ops/kv-cache-utils.d.ts

@@ -12,7 +12,7 @@ export declare function getCurrentCacheInfo(modelId: string, configHash: string,
     cachePath: string;
 }>;
 export declare function renameCacheFile(oldPath: string, newPath: string): Promise<boolean>;
-export declare function pruneEmptyCacheDirectories(cacheFilePath: string): Promise<void>;
+export declare function pruneEmptyCacheDirectories(cacheFilePath: string, activePaths?: readonly string[]): Promise<void>;
 export declare function deleteCache(options: {
     all: true;
 } | {

package/dist/server/bare/ops/kv-cache-utils.js

@@ -3,6 +3,7 @@ import { promises as fsPromises } from 'bare-fs';
 import path from 'bare-path';
 import { getAutoCacheLookupHistory, getKVCacheDir, validateAndJoinPath } from '../../../server/utils/index.js';
 import { getServerLogger } from '../../../logging/index.js';
+import { PathTraversalError } from '../../../utils/errors-server.js';
 import { Buffer } from 'bare-buffer';
 import { markAutoCacheKey } from '../../../server/bare/ops/kv-cache-retention.js';
 const logger = getServerLogger();
@@ -14,20 +15,28 @@ export function extractSystemPrompt(messages) {
     const systemMessage = messages.find((msg) => msg.role === 'system');
     return systemMessage ? systemMessage.content : null;
 }
-function getToolNamesForHash(tools) {
-    if (!Array.isArray(tools))
-        return [];
-    return tools
-        .map((t) => t.name)
-        .filter((n) => typeof n === 'string')
-        .sort();
+// Cache hash based on the system prompt + complete tool definitions.
+// Callers pass tools only when the tool block is written into the cache and
+// left there, so a different tool set gets its own cache instead of reusing a
+// prefix that holds the old block. Every prompt-affecting field participates,
+// not just the name: canonical serialization avoids cache misses caused only
+// by object-key insertion order, while tool-array order is preserved because
+// that is the order sent to the model.
+function canonicalizeHashInput(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalizeHashInput);
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const canonical = {};
+    for (const key of Object.keys(value).sort()) {
+        canonical[key] = canonicalizeHashInput(value[key]);
+    }
+    return canonical;
 }
-// Cache hash based on system prompt + tool names
-// Different tools = different cache (tools anchored in first message, protected from n_discarded)
 export function generateConfigHash(systemPrompt, tools) {
     const hash = crypto.createHash('sha-256');
-    const toolNames = getToolNamesForHash(tools);
-    hash.update(Buffer.from(JSON.stringify({ systemPrompt, toolNames }), 'utf8'));
+    const canonicalConfig = JSON.stringify(canonicalizeHashInput({ systemPrompt, tools: Array.isArray(tools) ? tools : [] }));
+    hash.update(Buffer.from(canonicalConfig, 'utf8'));
     return hash.digest('hex').substring(0, 16);
 }
 export function generateCacheKey(messages) {
@@ -88,11 +97,15 @@ export async function renameCacheFile(oldPath, newPath) {
         return false;
     }
 }
-export async function pruneEmptyCacheDirectories(cacheFilePath) {
+export async function pruneEmptyCacheDirectories(cacheFilePath, activePaths = []) {
     const cacheDir = getKVCacheDir();
     const cacheDirPrefix = `${cacheDir}${path.sep}`;
     let currentDirectory = path.dirname(cacheFilePath);
     while (currentDirectory.startsWith(cacheDirPrefix)) {
+        // Keep a directory another in-flight turn still holds (its .bin isn't on disk yet).
+        const childPrefix = `${currentDirectory}${path.sep}`;
+        if (activePaths.some((p) => p.startsWith(childPrefix)))
+            return;
         try {
             await fsPromises.rmdir(currentDirectory);
         }
@@ -113,8 +126,23 @@ export async function deleteCache(options) {
         await fsPromises.mkdir(cacheDir, { recursive: true });
         return cacheDir;
     }
+    // validateAndJoinPath sanitizes the key (strips traversal) and rejects
+    // escapes, so nested and other in-root keys resolve normally. A key that
+    // resolves to the cache root would wipe every cache — reject it BEFORE joining
+    // any modelId, so an empty key plus a modelId can't delete a real key dir
+    // under the root.
+    const cacheRoot = path.resolve(cacheDir);
     const kvCacheDir = validateAndJoinPath(cacheDir, options.kvCacheKey);
+    if (path.resolve(kvCacheDir) === cacheRoot) {
+        throw new PathTraversalError(options.kvCacheKey, cacheDir);
+    }
+    // Omitting modelId means "delete every model under the key"; a PROVIDED but
+    // empty/dot modelId collapses back to that same dir and would silently broaden
+    // the delete — reject it.
     const targetDir = options.modelId !== undefined ? validateAndJoinPath(kvCacheDir, options.modelId) : kvCacheDir;
+    if (options.modelId !== undefined && path.resolve(targetDir) === path.resolve(kvCacheDir)) {
+        throw new PathTraversalError(options.modelId, kvCacheDir);
+    }
     await fsPromises.rm(targetDir, { recursive: true, force: true });
     return targetDir;
 }

package/dist/server/bare/ops/transcribe.d.ts

@@ -15,6 +15,6 @@ export interface TranscribeStreamOpts {
     vadRunIntervalMs?: number;
     parakeetStreamingConfig?: ParakeetStreamingRunConfig;
 }
-export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt: string | undefined, metadata: true, opts?: TranscribeStreamOpts, requestId?: string): AsyncGenerator<TranscribeSegment | TranscribeStreamEvent, void, void>;
-export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt?: string, metadata?: boolean, opts?: TranscribeStreamOpts, requestId?: string): AsyncGenerator<string | TranscribeStreamEvent, void, void>;
+export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt: string | undefined, metadata: true, opts?: TranscribeStreamOpts, requestId?: string): AsyncGenerator<TranscribeSegment | TranscribeStreamEvent, TranscribeReturn, void>;
+export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt?: string, metadata?: boolean, opts?: TranscribeStreamOpts, requestId?: string): AsyncGenerator<string | TranscribeStreamEvent, TranscribeReturn, void>;
 //# sourceMappingURL=transcribe.d.ts.map

package/dist/server/bare/ops/transcribe.js

@@ -100,6 +100,55 @@ async function restorePrompt(modelId, originalConfig) {
         return;
     await model.reload(buildWhisperReloadConfig({ ...originalConfig, initial_prompt: '' }));
 }
+function mapTranscribeStats(stats) {
+    return {
+        ...(stats?.audioDurationMs !== undefined && {
+            audioDuration: stats.audioDurationMs
+        }),
+        ...(stats?.realTimeFactor !== undefined && {
+            realTimeFactor: stats.realTimeFactor
+        }),
+        ...(stats?.tokensPerSecond !== undefined && {
+            tokensPerSecond: stats.tokensPerSecond
+        }),
+        ...(stats?.totalTokens !== undefined && {
+            totalTokens: stats.totalTokens
+        }),
+        ...(stats?.totalSegments !== undefined && {
+            totalSegments: stats.totalSegments
+        }),
+        ...(stats?.whisperEncodeMs !== undefined && {
+            whisperEncodeTime: stats.whisperEncodeMs
+        }),
+        ...(stats?.whisperDecodeMs !== undefined && {
+            whisperDecodeTime: stats.whisperDecodeMs
+        }),
+        ...(stats?.encoderMs !== undefined && {
+            encoderTime: stats.encoderMs
+        }),
+        ...(stats?.decoderMs !== undefined && {
+            decoderTime: stats.decoderMs
+        }),
+        ...(stats?.melSpecMs !== undefined && {
+            melSpecTime: stats.melSpecMs
+        }),
+        ...(stats?.backendDevice !== undefined && {
+            backendDevice: stats.backendDevice
+        }),
+        ...(stats?.backendId !== undefined && {
+            backendId: stats.backendId
+        }),
+        ...(stats?.gpuUnsupported !== undefined && {
+            gpuUnsupported: stats.gpuUnsupported
+        }),
+        ...(stats?.gpuMemTotalMb !== undefined && {
+            gpuMemTotalMb: stats.gpuMemTotalMb
+        }),
+        ...(stats?.gpuMemFreeMb !== undefined && {
+            gpuMemFreeMb: stats.gpuMemFreeMb
+        })
+    };
+}
 export async function* transcribe(params, requestId) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
@@ -173,54 +222,7 @@ export async function* transcribe(params, requestId) {
             }
         }
         const modelExecutionMs = nowMs() - modelStart;
-        const stats = {
-            ...(response.stats?.audioDurationMs !== undefined && {
-                audioDuration: response.stats.audioDurationMs
-            }),
-            ...(response.stats?.realTimeFactor !== undefined && {
-                realTimeFactor: response.stats.realTimeFactor
-            }),
-            ...(response.stats?.tokensPerSecond !== undefined && {
-                tokensPerSecond: response.stats.tokensPerSecond
-            }),
-            ...(response.stats?.totalTokens !== undefined && {
-                totalTokens: response.stats.totalTokens
-            }),
-            ...(response.stats?.totalSegments !== undefined && {
-                totalSegments: response.stats.totalSegments
-            }),
-            ...(response.stats?.whisperEncodeMs !== undefined && {
-                whisperEncodeTime: response.stats.whisperEncodeMs
-            }),
-            ...(response.stats?.whisperDecodeMs !== undefined && {
-                whisperDecodeTime: response.stats.whisperDecodeMs
-            }),
-            ...(response.stats?.encoderMs !== undefined && {
-                encoderTime: response.stats.encoderMs
-            }),
-            ...(response.stats?.decoderMs !== undefined && {
-                decoderTime: response.stats.decoderMs
-            }),
-            ...(response.stats?.melSpecMs !== undefined && {
-                melSpecTime: response.stats.melSpecMs
-            }),
-            ...(response.stats?.backendDevice !== undefined && {
-                backendDevice: response.stats.backendDevice
-            }),
-            ...(response.stats?.backendId !== undefined && {
-                backendId: response.stats.backendId
-            }),
-            ...(response.stats?.gpuUnsupported !== undefined && {
-                gpuUnsupported: response.stats.gpuUnsupported
-            }),
-            ...(response.stats?.gpuMemTotalMb !== undefined && {
-                gpuMemTotalMb: response.stats.gpuMemTotalMb
-            }),
-            ...(response.stats?.gpuMemFreeMb !== undefined && {
-                gpuMemFreeMb: response.stats.gpuMemFreeMb
-            })
-        };
-        return buildStreamResult(modelExecutionMs, stats);
+        return buildStreamResult(modelExecutionMs, mapTranscribeStats(response.stats));
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -286,6 +288,7 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
             ctx.signal.removeEventListener('abort', onAbort);
         });
         const runOpts = buildRunStreamingOpts(engineType, opts);
+        const modelStart = nowMs();
         const response = await model.runStreaming(audioInputStream, runOpts);
         for await (const output of response.iterate()) {
             if (ctx.signal.aborted)
@@ -316,6 +319,9 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
                 yield* emitSegment(segment, metadata, silenceMarker);
             }
         }
+        await response.await();
+        const modelExecutionMs = nowMs() - modelStart;
+        return buildStreamResult(modelExecutionMs, mapTranscribeStats(response.stats));
     }
     catch (e_2) {
         env_2.error = e_2;

package/dist/server/bare/ops/translate-stats.d.ts

@@ -0,0 +1,5 @@
+import type { TranslationStats } from '../../../schemas/index.js';
+import type { NmtStats } from '../../../server/bare/types/addon-responses.js';
+export declare const NMT_SECONDS_TO_MS = 1000;
+export declare function buildNmtTranslationStats(stats: Partial<NmtStats> | undefined): TranslationStats;
+//# sourceMappingURL=translate-stats.d.ts.map

package/dist/server/bare/ops/translate-stats.js

@@ -0,0 +1,11 @@
+export const NMT_SECONDS_TO_MS = 1000;
+export function buildNmtTranslationStats(stats) {
+    return {
+        ...(stats?.totalTime !== undefined && { totalTime: stats.totalTime * NMT_SECONDS_TO_MS }),
+        ...(stats?.totalTokens !== undefined && { totalTokens: stats.totalTokens }),
+        ...(stats?.decodeTime !== undefined && { decodeTime: stats.decodeTime * NMT_SECONDS_TO_MS }),
+        ...(stats?.encodeTime !== undefined && { encodeTime: stats.encodeTime * NMT_SECONDS_TO_MS }),
+        ...(stats?.TPS !== undefined && { tokensPerSecond: stats.TPS }),
+        ...(stats?.TTFT !== undefined && { timeToFirstToken: stats.TTFT })
+    };
+}

package/dist/server/bare/ops/translate.js

@@ -55,9 +55,12 @@ import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LAN
 import { getLangName, detectOne } from '@qvac/langdetect-text';
 import { nowMs } from '../../../profiling/index.js';
 import { buildStreamResult } from '../../../profiling/model-execution.js';
+import { buildNmtTranslationStats } from '../../../server/bare/ops/translate-stats.js';
 import { ModelIsDelegatedError, ModelNotFoundError, ModelTypeMismatchError, TranslationFailedError } from '../../../utils/errors-server.js';
 import { getRequestRegistry, withRequestContext } from '../../../server/bare/runtime/index.js';
+import { isAddonContextOverflowError } from '../../../server/bare/plugins/llamacpp-completion/ops/context-overflow.js';
 import { generateServerRequestId } from '../../../server/bare/runtime/request-id.js';
+import { getModelParallel } from '../../../server/utils/index.js';
 import { getServerLogger } from '../../../logging/index.js';
 export function getLanguage(code) {
     if (!code)
@@ -121,38 +124,47 @@ export async function* translate(params, requestId) {
         const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
         const fromLanguage = getLanguage(from);
         const toLanguage = getLanguage(to);
-        // Open a request-scoped lifecycle for both engine branches. LLM-
-        // translate inherits llamacpp-completion's `{ scope: "model",
-        // hard: true }` cancel surface; NMT-translate inherits nmtcpp's
-        // `{ scope: "none" }` — so the addon-cancel wiring below only
-        // engages on the LLM path. NMT cancel is purely soft: the loop
-        // exits on `signal.aborted`, scope unwinds, and the addon may run
-        // to completion in the background — acceptable because the result
-        // is dropped either way.
+        // Open a request-scoped lifecycle for both engine branches. The LLM
+        // path cancels only its own run response (wired below), so a peer
+        // completion on the same model keeps running; NMT-translate has no
+        // addon cancel — the loop exits on `signal.aborted`, scope unwinds,
+        // and the addon may run to completion in the background, which is
+        // fine because the result is dropped either way.
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
             kind: 'translate',
-            modelId
+            modelId,
+            // LLM translate joins the completion lane (its cap = the model's own
+            // `parallel`); NMT passes no cap and stays ungated on its own model.
+            ...(isLlm && {
+                maxConcurrentPerModel: getModelParallel(entry.local.config)
+            })
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
+        // Cancel only this run's response, not the addon's global cancel, so a peer
+        // completion keeps running.
+        let activeResponse = null;
+        const cancelActive = () => {
+            activeResponse?.cancel().catch((err) => {
+                requestLogger.warn(`[cancel] translate response.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        };
         if (isLlm) {
-            const onAbort = () => {
-                const addon = model.addon;
-                if (addon?.cancel) {
-                    addon.cancel.call(addon).catch((err) => {
-                        requestLogger.warn(`[cancel] addon.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
-                    });
-                }
-            };
-            ctx.signal.addEventListener('abort', onAbort, { once: true });
+            ctx.signal.addEventListener('abort', cancelActive, { once: true });
             if (ctx.signal.aborted)
-                onAbort();
+                cancelActive();
             ctx.scope.defer(() => {
-                ctx.signal.removeEventListener('abort', onAbort);
+                ctx.signal.removeEventListener('abort', cancelActive);
+                activeResponse = null;
             });
         }
         // Check if input is an array and model type is NMT
         if (Array.isArray(text) && canonicalModelType === ModelType.nmtcppTranslation) {
+            // A cancel that landed before native work (e.g. the model is being unloaded)
+            // must not start the batch. Bail before runBatch, dropping the result.
+            if (ctx.signal.aborted) {
+                return { modelExecutionMs: 0 };
+            }
             // Use runBatch for batch processing
             const modelStart = nowMs();
             const translations = await model.runBatch(text);
@@ -188,6 +200,15 @@ export async function* translate(params, requestId) {
                         : `${context ? `${context}. ` : ''}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${singleText}\n${toLanguage}:`
                 }
             ];
+        // A translate cancelled before native work (queued-cancel, or the model being
+        // unloaded) must not call run(): LLM could decode against an exclusive finetune
+        // holding the lane, and either engine would run against a model being torn
+        // down. Bail with an empty soft-cancel result for both engines — the server
+        // never throws InferenceCancelledError (that error is client-constructed and
+        // would cross the RPC as a generic error).
+        if (ctx.signal.aborted) {
+            return { modelExecutionMs: 0 };
+        }
         const modelStart = nowMs();
         let response;
         if (canonicalModelType === ModelType.llamacppCompletion &&
@@ -199,14 +220,34 @@ export async function* translate(params, requestId) {
         else {
             response = await model.run(input);
         }
+        if (isLlm) {
+            activeResponse = response;
+            // A cancel that landed while `run(...)` was admitting still applies.
+            if (ctx.signal.aborted)
+                cancelActive();
+        }
         // Check if the response has an iterate method (like LLM models)
         if (canonicalModelType === ModelType.llamacppCompletion &&
             typeof response.iterate === 'function') {
             const llmResponse = response;
-            for await (const token of llmResponse.iterate()) {
-                if (ctx.signal.aborted)
-                    break;
-                yield token;
+            try {
+                for await (const token of llmResponse.iterate()) {
+                    if (ctx.signal.aborted)
+                        break;
+                    yield token;
+                }
+            }
+            catch (err) {
+                // A context-overflow rejection is a real terminal condition, not a
+                // cancellation — surface it even under an aborted signal, as completion does.
+                if (isAddonContextOverflowError(err))
+                    throw err;
+                // The request signal is the SDK-owned cancellation contract. Addon
+                // rejection shapes differ for active and queued native sequences, so once
+                // cancellation is accepted the translate ends cleanly regardless of that
+                // transport detail; without an abort, every error still propagates.
+                if (!ctx.signal.aborted)
+                    throw err;
             }
             const modelExecutionMs = nowMs() - modelStart;
             const stats = {
@@ -228,20 +269,7 @@ export async function* translate(params, requestId) {
             yield token;
         }
         const modelExecutionMs = nowMs() - modelStart;
-        const stats = {
-            ...(nmtResponse.stats?.totalTime !== undefined && { totalTime: nmtResponse.stats.totalTime }),
-            ...(nmtResponse.stats?.totalTokens !== undefined && {
-                totalTokens: nmtResponse.stats.totalTokens
-            }),
-            ...(nmtResponse.stats?.decodeTime !== undefined && {
-                decodeTime: nmtResponse.stats.decodeTime
-            }),
-            ...(nmtResponse.stats?.encodeTime !== undefined && {
-                encodeTime: nmtResponse.stats.encodeTime
-            }),
-            ...(nmtResponse.stats?.TPS !== undefined && { tokensPerSecond: nmtResponse.stats.TPS }),
-            ...(nmtResponse.stats?.TTFT !== undefined && { timeToFirstToken: nmtResponse.stats.TTFT })
-        };
+        const stats = buildNmtTranslationStats(nmtResponse.stats);
         return buildStreamResult(modelExecutionMs, stats);
     }
     catch (e_1) {

package/dist/server/bare/ops/unload-model.js

@@ -1,6 +1,7 @@
 import { promises as fsPromises } from 'bare-fs';
 import path from 'bare-path';
 import { unregisterModel } from '../../../server/bare/registry/model-registry.js';
+import { getRequestRegistry } from '../../../server/bare/runtime/index.js';
 import { unregisterAllLoggingStreams } from '../../../server/bare/registry/logging-stream-registry.js';
 import { clearFinetuneRuntimeState } from '../../../server/bare/plugins/llamacpp-completion/ops/finetune.js';
 import { unregisterAddonLogger, getServerLogger } from '../../../logging/index.js';
@@ -15,31 +16,36 @@ export async function unloadModel(params) {
     if (!entry) {
         throw new ModelNotLoadedError(modelId);
     }
-    clearFinetuneRuntimeState(modelId);
-    if (!entry.isDelegated) {
-        if (entry.local.model.unload) {
-            await entry.local.model.unload();
-        }
-        if (clearStorage && entry.local.path) {
-            const modelPath = entry.local.path;
-            const modelFileName = path.basename(modelPath);
-            const shardInfo = detectShardedModel(modelFileName);
-            if (shardInfo.isSharded) {
-                const shardDir = path.dirname(modelPath);
-                await fsPromises.rm(shardDir, { recursive: true, force: true });
-                logger.info(`Sharded model storage cleared: ${shardDir}`);
+    // Cancel and drain the model's requests, then tear down under the admission
+    // barrier so nothing goes active against a model being freed. The barrier is
+    // lifted for us when this resolves.
+    await getRequestRegistry().withModelDraining(modelId, async () => {
+        clearFinetuneRuntimeState(modelId);
+        if (!entry.isDelegated) {
+            if (entry.local.model.unload) {
+                await entry.local.model.unload();
             }
-            else {
-                const target = getClearStorageTarget(modelPath);
-                await fsPromises.rm(target.path, {
-                    recursive: target.kind === 'directory',
-                    force: true
-                });
-                logger.info(`Model storage cleared (${target.kind}): ${target.path}`);
+            if (clearStorage && entry.local.path) {
+                const modelPath = entry.local.path;
+                const modelFileName = path.basename(modelPath);
+                const shardInfo = detectShardedModel(modelFileName);
+                if (shardInfo.isSharded) {
+                    const shardDir = path.dirname(modelPath);
+                    await fsPromises.rm(shardDir, { recursive: true, force: true });
+                    logger.info(`Sharded model storage cleared: ${shardDir}`);
+                }
+                else {
+                    const target = getClearStorageTarget(modelPath);
+                    await fsPromises.rm(target.path, {
+                        recursive: target.kind === 'directory',
+                        force: true
+                    });
+                    logger.info(`Model storage cleared (${target.kind}): ${target.path}`);
+                }
             }
         }
-    }
-    unregisterAddonLogger(modelId);
-    unregisterAllLoggingStreams(modelId);
-    logger.info(`Model ${modelId} unloaded`);
+        unregisterAddonLogger(modelId);
+        unregisterAllLoggingStreams(modelId);
+        logger.info(`Model ${modelId} unloaded`);
+    });
 }

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-input.d.ts

@@ -0,0 +1,20 @@
+import { type AudioGenAudioInput } from '../../../../../schemas/audio-gen.js';
+export type AudioGenAudioInputName = 'referenceAudio' | 'sourceAudio';
+/**
+ * Resolve a reference/source audio input into the interleaved stereo 48 kHz
+ * Float32 PCM the ACE-Step engine consumes.
+ *
+ * - `base64` inputs (client `Buffer`/`Uint8Array`) must already be raw
+ *   interleaved stereo 48 kHz Float32 LE PCM; they are handed over as-is
+ *   (a copy is made only when the bytes are not 4-byte aligned).
+ * - `filePath` inputs with a decodable extension (`.wav`, `.mp3`, `.m4a`,
+ *   `.ogg`, `.flac`, `.aac`) are decoded through the SDK's FFmpeg decoder to
+ *   48 kHz mono float PCM and duplicated onto both channels. Any other
+ *   extension is streamed in as raw interleaved stereo 48 kHz Float32 LE PCM.
+ *
+ * Every path is bounded by `AUDIOGEN_INPUT_MAX_SECONDS` and rejects
+ * non-finite samples, so malformed or oversized input fails with
+ * `InvalidAudioInputError` before the engine is invoked.
+ */
+export declare function resolveAudioGenPcm(input: AudioGenAudioInput, name: AudioGenAudioInputName): Promise<Float32Array>;
+//# sourceMappingURL=audio-gen-input.d.ts.map