@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,29 +0,0 @@
-import { type CancelInferenceBaseParams } from '../../../schemas/index.js';
-import type { RequestKind } from '../../../server/bare/runtime/index.js';
-/**
- * Broad cancel: abort every in-flight request matching `modelId` (and
- * optionally a `kind`). Maps onto `RequestRegistry.cancel({ modelId })`
- * — the registry walks active contexts and aborts each one's signal,
- * which each handler has wired to its own addon-level / async unwind
- * via the registry's `await using ctx = await registry.begin(...)` block.
- *
- * Kept as a stable surface alongside the new `cancel({ requestId })`
- * path: the caller may not have a `requestId` to hand (model unload,
- * app shutdown, admin sweeps), and the escape hatch is cheap because
- * the registry already does the matching.
- *
- * Returns the number of contexts whose abort was triggered by *this*
- * call (already-cancelled contexts are skipped so callers can rely on
- * the count to log "n requests cancelled" once). Used by the RPC
- * cancel handler to populate `CancelResponse.cancelled` and by
- * internal server-side callers that want to know whether anything
- * landed.
- *
- * The legacy pre-registry addon-cancel fallback was removed in 0.11.0
- * once every handler had been migrated onto the registry; the function
- * now does exactly one thing — a registry walk.
- */
-export declare function cancel(params: CancelInferenceBaseParams, opts?: {
-    kind?: RequestKind;
-}): number;
-//# sourceMappingURL=cancel.d.ts.map

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

@@ -1,46 +0,0 @@
-import { getModel } from '../../../server/bare/registry/model-registry.js';
-import { cancelInferenceBaseSchema } from '../../../schemas/index.js';
-import { ModelNotLoadedError } from '../../../utils/errors-server.js';
-import { getRequestRegistry } from '../../../server/bare/runtime/index.js';
-import { getServerLogger } from '../../../logging/index.js';
-const logger = getServerLogger();
-/**
- * Broad cancel: abort every in-flight request matching `modelId` (and
- * optionally a `kind`). Maps onto `RequestRegistry.cancel({ modelId })`
- * — the registry walks active contexts and aborts each one's signal,
- * which each handler has wired to its own addon-level / async unwind
- * via the registry's `await using ctx = await registry.begin(...)` block.
- *
- * Kept as a stable surface alongside the new `cancel({ requestId })`
- * path: the caller may not have a `requestId` to hand (model unload,
- * app shutdown, admin sweeps), and the escape hatch is cheap because
- * the registry already does the matching.
- *
- * Returns the number of contexts whose abort was triggered by *this*
- * call (already-cancelled contexts are skipped so callers can rely on
- * the count to log "n requests cancelled" once). Used by the RPC
- * cancel handler to populate `CancelResponse.cancelled` and by
- * internal server-side callers that want to know whether anything
- * landed.
- *
- * The legacy pre-registry addon-cancel fallback was removed in 0.11.0
- * once every handler had been migrated onto the registry; the function
- * now does exactly one thing — a registry walk.
- */
-export function cancel(params, opts) {
-    const { modelId } = cancelInferenceBaseSchema.parse(params);
-    const model = getModel(modelId);
-    if (!model) {
-        throw new ModelNotLoadedError(modelId);
-    }
-    const registry = getRequestRegistry();
-    const target = opts?.kind ? { modelId, kind: opts.kind } : { modelId };
-    const cancelled = registry.cancel(target);
-    if (cancelled === 0) {
-        // Callers (workbench "Stop" button, app shutdown sweeps) often
-        // fire-and-forget; log so operators can see when a broad cancel
-        // landed against a registry with nothing in flight on this model.
-        logger.debug(`[cancel] no in-flight request matched modelId=${modelId}${opts?.kind ? ` kind=${opts.kind}` : ''}`);
-    }
-    return cancelled;
-}

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

@@ -1,16 +0,0 @@
-import { type EmbedParams, type EmbedStats } from '../../../schemas/index.js';
-export interface EmbedResult {
-    embedding: number[] | number[][];
-    stats?: EmbedStats;
-}
-export declare function embed(params: {
-    modelId: string;
-    text: string;
-}, requestId?: string): Promise<EmbedResult>;
-export declare function embed(params: {
-    modelId: string;
-    text: string[];
-}, requestId?: string): Promise<EmbedResult>;
-export declare function embed(params: EmbedParams, requestId?: string): Promise<EmbedResult>;
-export declare function normalizeVector(vector: Float32Array): number[];
-//# sourceMappingURL=embed.d.ts.map

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

@@ -1,193 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { getModel } from '../../../server/bare/registry/model-registry.js';
-import { embedParamsSchema } from '../../../schemas/index.js';
-import { buildUnaryResult } from '../../../profiling/model-execution.js';
-import { EmbedNoEmbeddingsError, EmbedFailedError, InferenceCancelledError } from '../../../utils/errors-server.js';
-import { nowMs } from '../../../profiling/index.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';
-export async function embed(params, requestId) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const { modelId, text } = embedParamsSchema.parse(params);
-        // Open a request-scoped lifecycle. The registry routes
-        // `cancel({ requestId })` and broad `cancel({ modelId, kind: "embeddings" })`
-        // straight to this context's signal. Falls back to a server-generated
-        // id if the client didn't send one (older releases).
-        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
-            requestId: requestId ?? generateServerRequestId(),
-            kind: 'embeddings',
-            modelId
-        })
-        // `requestLogger` is intentionally referenced once so the
-        // request-scoped logger is built at handler entry per the canonical
-        // shape, even when this op has no per-step emits beyond the
-        // registry's own lifecycle lines. Future addon-level warns inside
-        // this body should route through `requestLogger`.
-        , true);
-        // `requestLogger` is intentionally referenced once so the
-        // request-scoped logger is built at handler entry per the canonical
-        // shape, even when this op has no per-step emits beyond the
-        // registry's own lifecycle lines. Future addon-level warns inside
-        // this body should route through `requestLogger`.
-        const requestLogger = withRequestContext(getServerLogger(), ctx);
-        const model = getModel(modelId);
-        // Hard-cancel wiring: llamacpp-embedding declares
-        // `cancel: { scope: "model", hard: true }`. The signal listener
-        // forwards an abort to the addon so C++ work stops as soon as the
-        // user cancels — mirrors the canonical handler shape documented in
-        // `request-lifecycle-primitives.mdc`. The post-await
-        // `signal.aborted` checks below are the soft-cancel safety net for
-        // the case where the abort fires between `model.run(...)` returning
-        // and `response.await()` resolving (both can take seconds on large
-        // batches).
-        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 });
-        // `{ once: true }` does not fire if the signal is already aborted at
-        // register time. The registry may abort synchronously when a
-        // cancel-before-begin race resolves or the parent signal was pre-
-        // aborted — re-use `onAbort` so the listener body is the single
-        // source of truth for "what cancel does."
-        if (ctx.signal.aborted)
-            onAbort();
-        ctx.scope.defer(() => {
-            ctx.signal.removeEventListener('abort', onAbort);
-        });
-        const modelStart = nowMs();
-        const response = (await model.run(text));
-        if (ctx.signal.aborted) {
-            throw new InferenceCancelledError(ctx.requestId);
-        }
-        const rawEmbeddings = await response.await();
-        if (ctx.signal.aborted) {
-            throw new InferenceCancelledError(ctx.requestId);
-        }
-        const modelExecutionMs = nowMs() - modelStart;
-        const stats = {
-            ...(response.stats?.total_time_ms !== undefined && { totalTime: response.stats.total_time_ms }),
-            ...(response.stats?.tokens_per_second !== undefined && {
-                tokensPerSecond: response.stats.tokens_per_second
-            }),
-            ...(response.stats?.total_tokens !== undefined && { totalTokens: response.stats.total_tokens }),
-            ...(response.stats?.backendDevice !== undefined && {
-                backendDevice: response.stats.backendDevice
-            }),
-            ...(response.stats?.context_size !== undefined && { contextSize: response.stats.context_size })
-        };
-        const embeddingsArray = rawEmbeddings[0];
-        if (Array.isArray(text)) {
-            if (!embeddingsArray || embeddingsArray.length === 0) {
-                throw new EmbedNoEmbeddingsError();
-            }
-            const embedding = embeddingsArray.map((embeddingVector) => {
-                if (!embeddingVector || embeddingVector.length === 0) {
-                    throw new EmbedNoEmbeddingsError();
-                }
-                return normalizeVector(embeddingVector);
-            });
-            return buildUnaryResult({ embedding }, modelExecutionMs, stats);
-        }
-        else {
-            const embeddingVector = embeddingsArray?.[0];
-            if (!embeddingVector || embeddingVector.length === 0) {
-                throw new EmbedNoEmbeddingsError();
-            }
-            return buildUnaryResult({ embedding: normalizeVector(embeddingVector) }, modelExecutionMs, stats);
-        }
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}
-export function normalizeVector(vector) {
-    let sumOfSquares = 0;
-    for (let i = 0; i < vector.length; i++) {
-        const value = vector[i];
-        if (!Number.isFinite(value)) {
-            throw new EmbedFailedError(`NormalizeVector: non-finite value at index ${i}: ${value}`);
-        }
-        sumOfSquares += value * value;
-    }
-    const magnitude = Math.sqrt(sumOfSquares);
-    const EPS_ZERO = 1e-12;
-    const UNIT_TOL = 1e-4;
-    // Handle bad norms
-    if (!Number.isFinite(magnitude) || magnitude < EPS_ZERO) {
-        return new Array(vector.length).fill(0);
-    }
-    // Early exit: already ~unit length
-    if (Math.abs(magnitude - 1) <= UNIT_TOL) {
-        return Array.from(vector);
-    }
-    const inverseMagnitude = 1 / magnitude;
-    const normalizedVector = new Array(vector.length);
-    for (let i = 0; i < vector.length; i++) {
-        normalizedVector[i] = vector[i] * inverseMagnitude;
-    }
-    return normalizedVector;
-}

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

@@ -1,12 +0,0 @@
-export interface AutoCacheRetentionOptions {
-    activeCachePaths: string[];
-    maxBytes: number;
-    maxIdleMs: number;
-    nowMs: number;
-}
-export declare function markAutoCacheKey(cacheKey: string): Promise<void>;
-export declare function removeAutoCacheMarker(cacheKey: string): Promise<void>;
-export declare function removeAutoCacheMarkerIfMissing(cacheKey: string): Promise<void>;
-export declare function isCachePathWithinDirectory(directoryPath: string, cachePath: string): boolean;
-export declare function planAutoCacheEvictions(options: AutoCacheRetentionOptions): Promise<string[]>;
-//# sourceMappingURL=kv-cache-retention.d.ts.map

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

@@ -1,132 +0,0 @@
-import { promises as fsPromises } from 'bare-fs';
-import path from 'bare-path';
-import { getKVCacheDir } from '../../../server/utils/index.js';
-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), '');
-    }
-    catch (error) {
-        logger.warn(`[kv-cache] Failed to write auto-cache retention marker. key=${cacheKey} error=${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export async function removeAutoCacheMarker(cacheKey) {
-    if (!AUTO_CACHE_KEY_PATTERN.test(cacheKey))
-        return;
-    try {
-        await fsPromises.unlink(getAutoCacheMarkerPath(cacheKey));
-    }
-    catch {
-        // The marker is best-effort cleanup metadata and may already be absent.
-    }
-}
-export async function removeAutoCacheMarkerIfMissing(cacheKey) {
-    if (!AUTO_CACHE_KEY_PATTERN.test(cacheKey))
-        return;
-    try {
-        await fsPromises.access(path.join(getKVCacheDir(), cacheKey));
-    }
-    catch {
-        await removeAutoCacheMarker(cacheKey);
-    }
-}
-export function isCachePathWithinDirectory(directoryPath, cachePath) {
-    const prefix = `${directoryPath}${path.sep}`;
-    return cachePath === directoryPath || cachePath.startsWith(prefix);
-}
-async function readDirectory(directoryPath) {
-    try {
-        return await fsPromises.readdir(directoryPath);
-    }
-    catch {
-        return null;
-    }
-}
-async function inspectAutoCacheEntry(cacheKey, activeCachePaths) {
-    const directoryPath = path.join(getKVCacheDir(), cacheKey);
-    const modelDirectories = await readDirectory(directoryPath);
-    if (modelDirectories === null)
-        return null;
-    let size = 0;
-    let lastModifiedMs = 0;
-    for (const modelDirectory of modelDirectories) {
-        const modelPath = path.join(directoryPath, modelDirectory.toString());
-        const fileNames = await readDirectory(modelPath);
-        if (fileNames === null)
-            continue;
-        for (const fileName of fileNames) {
-            try {
-                const stats = await fsPromises.stat(path.join(modelPath, fileName.toString()));
-                if (!stats.isFile())
-                    continue;
-                size += stats.size;
-                lastModifiedMs = Math.max(lastModifiedMs, stats.mtime.getTime());
-            }
-            catch {
-                // The cache may have moved or been rolled back while the sweep was inspecting it.
-            }
-        }
-    }
-    return {
-        cacheKey,
-        directoryPath,
-        size,
-        lastModifiedMs,
-        active: activeCachePaths.some((cachePath) => isCachePathWithinDirectory(directoryPath, cachePath))
-    };
-}
-export async function planAutoCacheEvictions(options) {
-    const rootEntries = await readDirectory(getKVCacheDir());
-    if (rootEntries === null)
-        return [];
-    const entries = [];
-    for (const rootEntry of rootEntries) {
-        const markerMatch = AUTO_CACHE_MARKER_PATTERN.exec(rootEntry.toString());
-        if (markerMatch === null)
-            continue;
-        const cacheKey = markerMatch[1];
-        if (cacheKey === undefined)
-            continue;
-        const entry = await inspectAutoCacheEntry(cacheKey, options.activeCachePaths);
-        if (entry === null) {
-            await removeAutoCacheMarker(cacheKey);
-            continue;
-        }
-        entries.push(entry);
-    }
-    let retainedBytes = entries.reduce((total, entry) => total + entry.size, 0);
-    const evictions = new Set();
-    for (const entry of entries) {
-        if (entry.active)
-            continue;
-        const expired = entry.lastModifiedMs === 0 ||
-            (options.maxIdleMs > 0 && options.nowMs - entry.lastModifiedMs > options.maxIdleMs);
-        if (!expired)
-            continue;
-        evictions.add(entry.cacheKey);
-        retainedBytes -= entry.size;
-    }
-    const oldestFirst = entries
-        .filter((entry) => !entry.active && !evictions.has(entry.cacheKey))
-        .sort((a, b) => a.lastModifiedMs - b.lastModifiedMs);
-    for (const entry of oldestFirst) {
-        if (retainedBytes <= options.maxBytes)
-            break;
-        evictions.add(entry.cacheKey);
-        retainedBytes -= entry.size;
-    }
-    return Array.from(evictions);
-}

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

@@ -1,22 +0,0 @@
-import { type CacheMessage } from '../../../server/utils/index.js';
-export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
-export declare function generateConfigHash(systemPrompt: string | null, tools?: unknown): string;
-export declare function generateCacheKey(messages: CacheMessage[]): string;
-export declare function getCacheFilePath(modelId: string, configHash: string, cacheKey: string): Promise<string>;
-export declare function findMatchingCache(modelId: string, configHash: string, currentHistory: CacheMessage[]): Promise<{
-    cacheKey: string;
-    cachePath: string;
-} | null>;
-export declare function getCurrentCacheInfo(modelId: string, configHash: string, currentHistory: CacheMessage[]): Promise<{
-    cacheKey: string;
-    cachePath: string;
-}>;
-export declare function renameCacheFile(oldPath: string, newPath: string): Promise<boolean>;
-export declare function pruneEmptyCacheDirectories(cacheFilePath: string, activePaths?: readonly string[]): Promise<void>;
-export declare function deleteCache(options: {
-    all: true;
-} | {
-    kvCacheKey: string;
-    modelId?: string;
-}): Promise<string>;
-//# sourceMappingURL=kv-cache-utils.d.ts.map

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

@@ -1,148 +0,0 @@
-import crypto from 'bare-crypto';
-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();
-// In-memory KV-cache state lives in `KvCacheSession` (the single
-// mutation point for all three KV-cache bookkeeping layers). This
-// module keeps only the pure path / hash utilities that don't touch
-// in-memory state.
-export function extractSystemPrompt(messages) {
-    const systemMessage = messages.find((msg) => msg.role === 'system');
-    return systemMessage ? systemMessage.content : null;
-}
-// 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;
-}
-export function generateConfigHash(systemPrompt, tools) {
-    const hash = crypto.createHash('sha-256');
-    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) {
-    const hash = crypto.createHash('sha-256');
-    const historyString = JSON.stringify(messages);
-    const historyBuffer = Buffer.from(historyString, 'utf8');
-    hash.update(historyBuffer);
-    const hashString = hash.digest('hex');
-    return hashString.substring(0, 16);
-}
-function resolveCacheFilePath(modelId, configHash, cacheKey) {
-    const cacheDir = getKVCacheDir();
-    const sessionCacheDir = validateAndJoinPath(cacheDir, cacheKey);
-    const modelCacheDir = validateAndJoinPath(sessionCacheDir, modelId);
-    return path.join(modelCacheDir, `${configHash}.bin`);
-}
-export async function getCacheFilePath(modelId, configHash, cacheKey) {
-    const cachePath = resolveCacheFilePath(modelId, configHash, cacheKey);
-    const modelCacheDir = path.dirname(cachePath);
-    try {
-        await fsPromises.mkdir(modelCacheDir, { recursive: true });
-    }
-    catch {
-        // Ignore if directories already exist
-    }
-    return cachePath;
-}
-// Used for auto-generated cache key
-export async function findMatchingCache(modelId, configHash, currentHistory) {
-    if (currentHistory.length <= 1) {
-        return null;
-    }
-    const previousHistory = getAutoCacheLookupHistory(currentHistory);
-    const cacheKey = generateCacheKey(previousHistory);
-    const cachePath = resolveCacheFilePath(modelId, configHash, cacheKey);
-    try {
-        await fsPromises.access(cachePath);
-        await markAutoCacheKey(cacheKey);
-        return { cacheKey, cachePath };
-    }
-    catch {
-        return null;
-    }
-}
-export async function getCurrentCacheInfo(modelId, configHash, currentHistory) {
-    const cacheKey = generateCacheKey(currentHistory);
-    await markAutoCacheKey(cacheKey);
-    const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
-    return { cacheKey, cachePath };
-}
-export async function renameCacheFile(oldPath, newPath) {
-    try {
-        await fsPromises.rename(oldPath, newPath);
-        return true;
-    }
-    catch (error) {
-        logger.error('Error renaming cache file:', error instanceof Error ? error.message : String(error));
-        return false;
-    }
-}
-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);
-        }
-        catch {
-            return;
-        }
-        currentDirectory = path.dirname(currentDirectory);
-    }
-}
-// Cache-existence probing (in-memory registry first, fall back to
-// `fs.access`) lives in `KvCacheSession.beginTurn(...)`. Keeping the
-// in-memory `initializedCaches` set private to the session module
-// avoids drift between the two layers.
-export async function deleteCache(options) {
-    const cacheDir = getKVCacheDir();
-    if ('all' in options) {
-        await fsPromises.rm(cacheDir, { recursive: true, force: true });
-        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/load-model.d.ts

@@ -1,9 +0,0 @@
-import { type LoadModelServerParams } from '../../../schemas/index.js';
-import type { LoadTimingStats } from '../../../profiling/types.js';
-export interface LoadModelResult {
-    timing?: LoadTimingStats;
-}
-export declare function loadModel(params: LoadModelServerParams, options?: {
-    collectTiming?: boolean;
-}): Promise<LoadModelResult>;
-//# sourceMappingURL=load-model.d.ts.map