@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/utils/gguf-tensor-extractor.js

@@ -1,310 +0,0 @@
-import { promises as fsPromises, createReadStream } from 'bare-fs';
-import { getServerLogger } from '../../logging/index.js';
-import { ModelLoadFailedError } from '../../utils/errors-server.js';
-import { validateAndJoinPath } from './path-security.js';
-const logger = getServerLogger();
-// GGUF value types
-const GGUF_TYPE = {
-    UINT8: 0,
-    INT8: 1,
-    UINT16: 2,
-    INT16: 3,
-    UINT32: 4,
-    INT32: 5,
-    FLOAT32: 6,
-    BOOL: 7,
-    STRING: 8,
-    ARRAY: 9,
-    UINT64: 10,
-    INT64: 11,
-    FLOAT64: 12
-};
-// Type sizes in bytes
-const TYPE_SIZE = {
-    [GGUF_TYPE.UINT8]: 1,
-    [GGUF_TYPE.INT8]: 1,
-    [GGUF_TYPE.UINT16]: 2,
-    [GGUF_TYPE.INT16]: 2,
-    [GGUF_TYPE.UINT32]: 4,
-    [GGUF_TYPE.INT32]: 4,
-    [GGUF_TYPE.FLOAT32]: 4,
-    [GGUF_TYPE.BOOL]: 1,
-    [GGUF_TYPE.UINT64]: 8,
-    [GGUF_TYPE.INT64]: 8,
-    [GGUF_TYPE.FLOAT64]: 8
-};
-// Limits to prevent DoS/corruption issues
-const LIMITS = {
-    MAX_KV_COUNT: 100_000,
-    MAX_TENSOR_COUNT: 1_000_000,
-    MAX_STRING_LEN: 100 * 1024 * 1024, // 100MB for tokenizer vocab
-    MAX_TENSOR_NAME_LEN: 64 * 1024, // 64KB for tensor names
-    MAX_ARRAY_LEN: 1_000_000_000, // 1B elements
-    MAX_DIMS: 32,
-    MAX_HEADER_SIZE: 4 * 1024 * 1024 * 1024 // 4GB max header
-};
-// Magic bytes for endianness detection
-const GGUF_MAGIC_LE = 0x46554747; // "GGUF" little-endian
-const GGUF_MAGIC_BE = 0x47475546; // "FUGG" big-endian
-// File-local error for streaming parser control flow
-// Used to signal "keep reading chunks" rather than an actual failure
-class NeedMoreDataError extends Error {
-    currentOffset;
-    bytesNeeded;
-    constructor(currentOffset, bytesNeeded) {
-        super(`Need more data: offset ${currentOffset} requires ${bytesNeeded} more bytes`);
-        this.name = 'NeedMoreDataError';
-        this.currentOffset = currentOffset;
-        this.bytesNeeded = bytesNeeded;
-    }
-}
-function parseGGUFHeader(buffer) {
-    const bufferLength = buffer.length;
-    let offset = 0;
-    let isBigEndian = false;
-    function ensureBytes(needed) {
-        if (offset + needed > bufferLength) {
-            throw new NeedMoreDataError(offset, needed);
-        }
-    }
-    function readU32() {
-        ensureBytes(4);
-        const val = isBigEndian ? buffer.readUInt32BE(offset) : buffer.readUInt32LE(offset);
-        offset += 4;
-        return val;
-    }
-    function readU64() {
-        ensureBytes(8);
-        const val = isBigEndian ? buffer.readBigUInt64BE(offset) : buffer.readBigUInt64LE(offset);
-        offset += 8;
-        return val;
-    }
-    function readU64AsNumber() {
-        const val = readU64();
-        if (val > BigInt(Number.MAX_SAFE_INTEGER)) {
-            throw new ModelLoadFailedError(`Value ${val} exceeds safe integer range`);
-        }
-        return Number(val);
-    }
-    function skipBytes(n) {
-        ensureBytes(n);
-        offset += n;
-    }
-    function skipString() {
-        const len = readU64AsNumber();
-        if (len > LIMITS.MAX_STRING_LEN) {
-            throw new ModelLoadFailedError(`String length ${len} exceeds limit ${LIMITS.MAX_STRING_LEN}`);
-        }
-        skipBytes(len);
-    }
-    function readTensorName() {
-        const len = readU64AsNumber();
-        if (len > LIMITS.MAX_TENSOR_NAME_LEN) {
-            logger.warn(`Tensor name length ${len} exceeds limit, truncating`);
-            skipBytes(len);
-            return '';
-        }
-        ensureBytes(len);
-        const name = buffer.toString('utf8', offset, offset + len);
-        offset += len;
-        return name;
-    }
-    function skipValue(valueType) {
-        const size = TYPE_SIZE[valueType];
-        if (size !== undefined) {
-            skipBytes(size);
-            return;
-        }
-        if (valueType === GGUF_TYPE.STRING) {
-            skipString();
-            return;
-        }
-        if (valueType === GGUF_TYPE.ARRAY) {
-            const arrayType = readU32();
-            const arrayLen = readU64AsNumber();
-            if (arrayLen > LIMITS.MAX_ARRAY_LEN) {
-                throw new ModelLoadFailedError(`Array length ${arrayLen} exceeds limit ${LIMITS.MAX_ARRAY_LEN}`);
-            }
-            const elementSize = TYPE_SIZE[arrayType];
-            if (elementSize !== undefined) {
-                // Fixed-size elements
-                skipBytes(arrayLen * elementSize);
-            }
-            else if (arrayType === GGUF_TYPE.STRING) {
-                // Array of strings
-                for (let i = 0; i < arrayLen; i++) {
-                    skipString();
-                }
-            }
-            else if (arrayType === GGUF_TYPE.ARRAY) {
-                throw new ModelLoadFailedError('Nested arrays not supported');
-            }
-            else {
-                throw new ModelLoadFailedError(`Unknown array element type: ${arrayType}`);
-            }
-            return;
-        }
-        throw new ModelLoadFailedError(`Unknown value type: ${valueType}`);
-    }
-    // Parse header
-    ensureBytes(4);
-    const magicLE = buffer.readUInt32LE(offset);
-    if (magicLE === GGUF_MAGIC_LE) {
-        isBigEndian = false;
-    }
-    else if (magicLE === GGUF_MAGIC_BE) {
-        isBigEndian = true;
-        logger.debug('Detected big-endian GGUF file');
-    }
-    else {
-        throw new ModelLoadFailedError(`Invalid GGUF file - magic number mismatch (got 0x${magicLE.toString(16)})`);
-    }
-    offset += 4;
-    // Version
-    const version = readU32();
-    if (version !== 2 && version !== 3) {
-        throw new ModelLoadFailedError(`Unsupported GGUF version: ${version}`);
-    }
-    // Tensor count and KV count
-    const tensorCount = readU64AsNumber();
-    const kvCount = readU64AsNumber();
-    if (tensorCount > LIMITS.MAX_TENSOR_COUNT) {
-        throw new ModelLoadFailedError(`Tensor count ${tensorCount} exceeds limit ${LIMITS.MAX_TENSOR_COUNT}`);
-    }
-    if (kvCount > LIMITS.MAX_KV_COUNT) {
-        throw new ModelLoadFailedError(`KV count ${kvCount} exceeds limit ${LIMITS.MAX_KV_COUNT}`);
-    }
-    // Skip all KV pairs
-    for (let i = 0; i < kvCount; i++) {
-        skipString();
-        const valueType = readU32();
-        skipValue(valueType);
-    }
-    logger.debug(`KV section complete at offset ${offset}, reading tensor names...`);
-    const tensorNames = [];
-    for (let i = 0; i < tensorCount; i++) {
-        const name = readTensorName();
-        if (name) {
-            tensorNames.push(name);
-        }
-        // n_dims (u32)
-        const nDims = readU32();
-        if (nDims > LIMITS.MAX_DIMS) {
-            throw new ModelLoadFailedError(`Tensor dimensions ${nDims} exceeds limit ${LIMITS.MAX_DIMS}`);
-        }
-        // shape: nDims * u64
-        skipBytes(nDims * 8);
-        // dtype (u32)
-        skipBytes(4);
-        // offset (u64)
-        skipBytes(8);
-    }
-    logger.debug(`Parsed ${tensorNames.length} tensor names successfully`);
-    return tensorNames;
-}
-async function extractTensorNamesFromHeader(filePath) {
-    const stream = createReadStream(filePath);
-    const chunks = [];
-    let totalRead = 0;
-    let streamDestroyed = false;
-    function destroyStream() {
-        if (!streamDestroyed) {
-            streamDestroyed = true;
-            stream.destroy();
-        }
-    }
-    try {
-        for await (const chunk of stream) {
-            chunks.push(chunk);
-            totalRead += chunk.length;
-            // Only attempt parsing once we have enough data for the basic header
-            if (totalRead >= 24) {
-                try {
-                    const buffer = Buffer.concat(chunks);
-                    const result = parseGGUFHeader(buffer);
-                    destroyStream();
-                    return result;
-                }
-                catch (error) {
-                    if (error instanceof NeedMoreDataError) {
-                        // Keep reading
-                        if (totalRead >= LIMITS.MAX_HEADER_SIZE) {
-                            throw new ModelLoadFailedError(`GGUF header exceeds ${LIMITS.MAX_HEADER_SIZE / (1024 * 1024 * 1024)}GB limit`);
-                        }
-                        continue;
-                    }
-                    throw error;
-                }
-            }
-        }
-        throw new ModelLoadFailedError('File ended before GGUF header could be parsed');
-    }
-    finally {
-        destroyStream();
-    }
-}
-/**
- * Extract tensor names from all GGUF shards and write to {baseFilename}.tensors.txt
- * Required for sharded models to enable incremental/async loading
- * @throws ModelLoadFailedError if any shard fails extraction
- */
-export async function extractAndWriteTensorsFile(shardDir, shardFilenames, baseFilename) {
-    const tensorsFilePath = validateAndJoinPath(shardDir, `${baseFilename}.tensors.txt`);
-    try {
-        await fsPromises.access(tensorsFilePath);
-        logger.info(`Tensors file already exists: ${tensorsFilePath}`);
-        return tensorsFilePath;
-    }
-    catch {
-        // Continue with extraction
-    }
-    logger.info(`Extracting tensors from ${shardFilenames.length} shards...`);
-    const allTensorNames = new Set();
-    const failedShards = [];
-    for (const filename of shardFilenames) {
-        const shardPath = validateAndJoinPath(shardDir, filename);
-        try {
-            logger.debug(`Extracting tensors from ${filename}...`);
-            const tensorNames = await extractTensorNamesFromHeader(shardPath);
-            if (tensorNames.length > 0) {
-                tensorNames.forEach((name) => allTensorNames.add(name));
-                logger.info(`Extracted ${tensorNames.length} tensors from ${filename}`);
-            }
-            else {
-                failedShards.push(filename);
-                logger.error(`No tensors found in ${filename}`);
-            }
-        }
-        catch (error) {
-            failedShards.push(filename);
-            logger.error(`Failed to extract tensors from ${filename}:`, error);
-        }
-    }
-    if (failedShards.length > 0) {
-        throw new ModelLoadFailedError(`Failed to extract tensors from ${failedShards.length}/${shardFilenames.length} shards: ${failedShards.join(', ')}`);
-    }
-    if (allTensorNames.size === 0) {
-        throw new ModelLoadFailedError(`Could not extract any tensors from shards.`);
-    }
-    const tensorNames = Array.from(allTensorNames).sort();
-    await fsPromises.writeFile(tensorsFilePath, tensorNames.join('\n') + '\n', 'utf8');
-    logger.info(`Tensors file created: ${tensorsFilePath} (${tensorNames.length} tensors from ${shardFilenames.length} shards)`);
-    return tensorsFilePath;
-}
-/**
- * Check if a file has a valid GGUF header structure.
- * Returns true if the header parses successfully and contains tensor metadata.
- *
- * NOTE: This only validates the header structure, NOT that tensor data exists.
- * A file can have a valid header but be incomplete.
- */
-export async function hasValidGGUFHeader(filePath) {
-    try {
-        const tensorNames = await extractTensorNamesFromHeader(filePath);
-        return tensorNames.length > 0;
-    }
-    catch (error) {
-        logger.warn(`⚠️ GGUF header validation failed: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
-    }
-}

package/dist/server/utils/index.d.ts

@@ -1,11 +0,0 @@
-export * from './archive.js';
-export * from './cache/types.js';
-export * from './cache/auto-history.js';
-export * from './cache/paths.js';
-export * from './checksum.js';
-export * from './config-transform.js';
-export * from './formatting.js';
-export * from './gguf-tensor-extractor.js';
-export * from './path-security.js';
-export * from './shard-utils.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,10 +0,0 @@
-export * from './archive.js';
-export * from './cache/types.js';
-export * from './cache/auto-history.js';
-export * from './cache/paths.js';
-export * from './checksum.js';
-export * from './config-transform.js';
-export * from './formatting.js';
-export * from './gguf-tensor-extractor.js';
-export * from './path-security.js';
-export * from './shard-utils.js';

package/dist/server/utils/multi-gpu-mobile.d.ts

@@ -1,5 +0,0 @@
-export declare const MULTI_GPU_KEYS: readonly ["main-gpu", "split-mode", "tensor-split"];
-type MultiGpuKey = (typeof MULTI_GPU_KEYS)[number];
-export declare function stripMultiGpuKeys(config: Record<string, unknown>): readonly MultiGpuKey[];
-export {};
-//# sourceMappingURL=multi-gpu-mobile.d.ts.map

package/dist/server/utils/multi-gpu-mobile.js

@@ -1,10 +0,0 @@
-export const MULTI_GPU_KEYS = ['main-gpu', 'split-mode', 'tensor-split'];
-// Deletes any multi-GPU keys from `config` IN PLACE and returns the removed
-// keys. Mutation is intentional: callers strip before the config reaches the
-// model constructor. gpu_layers (single-GPU layer offload) is intentionally
-// absent from MULTI_GPU_KEYS.
-export function stripMultiGpuKeys(config) {
-    const stripped = MULTI_GPU_KEYS.filter((k) => k in config);
-    stripped.forEach((k) => delete config[k]);
-    return stripped;
-}

package/dist/server/utils/path-security.d.ts

@@ -1,12 +0,0 @@
-export { sanitizePathComponent } from '../../utils/path-sanitize.js';
-/**
- * Check whether a target path is contained within a base directory.
- * Both paths are resolved to absolute before comparison.
- */
-export declare function isPathWithinBase(basePath: string, targetPath: string): boolean;
-/**
- * Sanitize components, join them to a base path, and verify the result
- * stays within the base directory. Throws PathTraversalError on escape.
- */
-export declare function validateAndJoinPath(basePath: string, ...components: string[]): string;
-//# sourceMappingURL=path-security.d.ts.map

package/dist/server/utils/path-security.js

@@ -1,25 +0,0 @@
-import path from 'bare-path';
-import { PathTraversalError } from '../../utils/errors-server.js';
-import { sanitizePathComponent, checkPathWithinBase } from '../../utils/path-sanitize.js';
-// Re-export sanitizePathComponent unchanged
-export { sanitizePathComponent } from '../../utils/path-sanitize.js';
-/**
- * Check whether a target path is contained within a base directory.
- * Both paths are resolved to absolute before comparison.
- */
-export function isPathWithinBase(basePath, targetPath) {
-    return checkPathWithinBase(basePath, targetPath, (...args) => path.resolve(...args), path.sep || '/');
-}
-/**
- * Sanitize components, join them to a base path, and verify the result
- * stays within the base directory. Throws PathTraversalError on escape.
- */
-export function validateAndJoinPath(basePath, ...components) {
-    const sanitized = components.map((c) => sanitizePathComponent(c));
-    const joined = path.join(basePath, ...sanitized);
-    const resolved = path.resolve(joined);
-    if (!isPathWithinBase(basePath, resolved)) {
-        throw new PathTraversalError(components.join('/'), basePath);
-    }
-    return resolved;
-}

package/dist/server/utils/qvac-paths.js

@@ -1,5 +0,0 @@
-import path from 'bare-path';
-import { getEnv } from '../../server/env.js';
-export function getQvacPath(...subPaths) {
-    return path.join(getEnv().HOME_DIR, '.qvac', ...subPaths);
-}

package/dist/server/utils/response-format.d.ts

@@ -1,3 +0,0 @@
-import type { ResponseFormat } from '../../schemas/index.js';
-export declare function getResponseFormatJsonSchema(responseFormat: ResponseFormat): string | undefined;
-//# sourceMappingURL=response-format.d.ts.map

package/dist/server/utils/response-format.js

@@ -1,20 +0,0 @@
-// Translates the request-level `responseFormat` into the JSON Schema string
-// that the llama.cpp addon's per-request `generationParams.json_schema`
-// expects. Returns `undefined` for `{ type: "text" }` (no constraint).
-//
-// The addon converts the schema to GBNF natively via
-// `json_schema_to_grammar()` and applies it for the duration of the request
-// only, restoring the prior sampling block afterwards — so this surface is
-// safe to use under concurrent completions on the same model. (Tool calling
-// still goes through `setupToolGrammar` / `modelConfig.grammar`; see the
-// mutual-exclusion check in `completionClientParamsSchema`.)
-export function getResponseFormatJsonSchema(responseFormat) {
-    switch (responseFormat.type) {
-        case 'text':
-            return undefined;
-        case 'json_object':
-            return JSON.stringify({ type: 'object' });
-        case 'json_schema':
-            return JSON.stringify(responseFormat.json_schema.schema);
-    }
-}

package/dist/server/utils/shard-utils.d.ts

@@ -1,49 +0,0 @@
-import type { ShardPatternInfo, ShardUrl } from '../../schemas/index.js';
-/**
- * Detect if model filename follows shard pattern (00001-of-0000x)
- */
-export declare function detectShardedModel(filename: string): ShardPatternInfo;
-export declare function getFirstShardPath(modelPath: string): string;
-/**
- * Generate list of shard filenames for a sharded model
- * Accepts any shard in the group
- *
- * @param shardName - Any shard filename in the group (e.g., "model-00002-of-00005.gguf")
- * @returns Array of all numbered shard filenames
- */
-export declare function generateShardFilenames(shardName: string): string[];
-/**
- * Parse pattern-based shard URL and generate all shard URLs with cache key
- * Works with patterns like: https://example.com/path/model-00002-of-00005.gguf
- *
- * @param shardUrl - Any shard URL in the group
- * @returns Object with shard URLs array and cache key
- */
-export declare function parsePatternBasedShardUrl(shardUrl: string): {
-    shardUrls: ShardUrl[];
-    cacheKey: string;
-};
-/**
- * Extract tensor information from all shards and write to baseFilename.tensors.txt
- * Required for sharded models to enable incremental/async loading
- * @param shardDir - Directory containing the shard files
- * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
- * @returns Path to the created tensors.txt file
- * @throws If not a sharded model or extraction fails
- */
-export declare function extractTensorsFromShards(shardDir: string, shardFilename: string): Promise<string>;
-/**
- * Check if all numbered shard files exist
- * @param shardDir - Directory containing the shard files
- * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
- * @returns true if all numbered shards exist, false otherwise
- */
-export declare function checkAllShardsExist(shardDir: string, shardFilename: string): Promise<boolean>;
-/**
- * Validate that all shards and tensors.txt exist for a sharded model
- * @param shardDir - Directory containing the shard files
- * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
- * @returns true if all shards and tensors.txt exist, false otherwise
- */
-export declare function validateShardedModelCache(shardDir: string, shardFilename: string): Promise<boolean>;
-//# sourceMappingURL=shard-utils.d.ts.map

package/dist/server/utils/shard-utils.js

@@ -1,137 +0,0 @@
-import { ModelLoadFailedError, InvalidShardUrlPatternError } from '../../utils/errors-server.js';
-import { generateShortHash } from './formatting.js';
-import { validateAndJoinPath } from './path-security.js';
-import { extractAndWriteTensorsFile } from './gguf-tensor-extractor.js';
-import { promises as fsPromises } from 'bare-fs';
-/**
- * Detect if model filename follows shard pattern (00001-of-0000x)
- */
-export function detectShardedModel(filename) {
-    const shardPattern = /^(.+)-(\d{5})-of-(\d{5})(\.\w+)$/;
-    const match = filename.match(shardPattern);
-    if (match && match[1] && match[2] && match[3] && match[4]) {
-        return {
-            isSharded: true,
-            baseFilename: match[1],
-            currentShard: parseInt(match[2], 10),
-            totalShards: parseInt(match[3], 10),
-            extension: match[4]
-        };
-    }
-    return { isSharded: false };
-}
-export function getFirstShardPath(modelPath) {
-    const lastSeparator = Math.max(modelPath.lastIndexOf('/'), modelPath.lastIndexOf('\\'));
-    const directory = lastSeparator >= 0 ? modelPath.slice(0, lastSeparator + 1) : '';
-    const filename = lastSeparator >= 0 ? modelPath.slice(lastSeparator + 1) : modelPath;
-    const shardInfo = detectShardedModel(filename);
-    if (!shardInfo.isSharded ||
-        !shardInfo.baseFilename ||
-        !shardInfo.totalShards ||
-        !shardInfo.extension) {
-        return modelPath;
-    }
-    const totalShards = shardInfo.totalShards.toString().padStart(5, '0');
-    return `${directory}${shardInfo.baseFilename}-00001-of-${totalShards}${shardInfo.extension}`;
-}
-/**
- * Generate list of shard filenames for a sharded model
- * Accepts any shard in the group
- *
- * @param shardName - Any shard filename in the group (e.g., "model-00002-of-00005.gguf")
- * @returns Array of all numbered shard filenames
- */
-export function generateShardFilenames(shardName) {
-    const shardInfo = detectShardedModel(shardName);
-    if (!shardInfo.isSharded || !shardInfo.totalShards) {
-        throw new ModelLoadFailedError(`Not a sharded model filename: ${shardName}`);
-    }
-    const filenames = [];
-    const { baseFilename, totalShards, extension } = shardInfo;
-    for (let i = 1; i <= totalShards; i++) {
-        const shardNumber = i.toString().padStart(5, '0');
-        const totalShardsStr = totalShards.toString().padStart(5, '0');
-        filenames.push(`${baseFilename}-${shardNumber}-of-${totalShardsStr}${extension}`);
-    }
-    return filenames;
-}
-/**
- * Parse pattern-based shard URL and generate all shard URLs with cache key
- * Works with patterns like: https://example.com/path/model-00002-of-00005.gguf
- *
- * @param shardUrl - Any shard URL in the group
- * @returns Object with shard URLs array and cache key
- */
-export function parsePatternBasedShardUrl(shardUrl) {
-    const urlParts = shardUrl.split('/');
-    const filename = urlParts[urlParts.length - 1]?.split('?')[0] || '';
-    const shardInfo = detectShardedModel(filename);
-    if (!shardInfo.isSharded || !shardInfo.baseFilename) {
-        throw new InvalidShardUrlPatternError(shardUrl);
-    }
-    const shardFilenames = generateShardFilenames(filename);
-    const baseUrl = urlParts.slice(0, -1).join('/');
-    return {
-        shardUrls: shardFilenames.map((shardFilename) => ({
-            url: `${baseUrl}/${shardFilename}`,
-            filename: shardFilename
-        })),
-        cacheKey: generateShortHash(`${baseUrl}/${shardInfo.baseFilename}`)
-    };
-}
-/**
- * Extract tensor information from all shards and write to baseFilename.tensors.txt
- * Required for sharded models to enable incremental/async loading
- * @param shardDir - Directory containing the shard files
- * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
- * @returns Path to the created tensors.txt file
- * @throws If not a sharded model or extraction fails
- */
-export async function extractTensorsFromShards(shardDir, shardFilename) {
-    const shardInfo = detectShardedModel(shardFilename);
-    if (!shardInfo.isSharded || !shardInfo.baseFilename || !shardInfo.totalShards) {
-        throw new ModelLoadFailedError(`Not a sharded model filename: ${shardFilename}`);
-    }
-    const allShardFilenames = generateShardFilenames(shardFilename);
-    return extractAndWriteTensorsFile(shardDir, allShardFilenames, shardInfo.baseFilename);
-}
-/**
- * Check if all numbered shard files exist
- * @param shardDir - Directory containing the shard files
- * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
- * @returns true if all numbered shards exist, false otherwise
- */
-export async function checkAllShardsExist(shardDir, shardFilename) {
-    const shardInfo = detectShardedModel(shardFilename);
-    if (!shardInfo.isSharded) {
-        return false;
-    }
-    const shardFilenames = generateShardFilenames(shardFilename);
-    const allShardsExist = await Promise.all(shardFilenames.map((f) => fsPromises
-        .access(validateAndJoinPath(shardDir, f))
-        .then(() => true)
-        .catch(() => false))).then((results) => results.every((exists) => exists));
-    return allShardsExist;
-}
-/**
- * Validate that all shards and tensors.txt exist for a sharded model
- * @param shardDir - Directory containing the shard files
- * @param shardFilename - Filename of any shard (e.g., "model-00001-of-00002.gguf")
- * @returns true if all shards and tensors.txt exist, false otherwise
- */
-export async function validateShardedModelCache(shardDir, shardFilename) {
-    const shardInfo = detectShardedModel(shardFilename);
-    if (!shardInfo.isSharded || !shardInfo.baseFilename) {
-        return false;
-    }
-    const allShardsExist = await checkAllShardsExist(shardDir, shardFilename);
-    if (!allShardsExist) {
-        return false;
-    }
-    const tensorsFile = `${shardInfo.baseFilename}.tensors.txt`;
-    const tensorsExist = await fsPromises
-        .access(validateAndJoinPath(shardDir, tensorsFile))
-        .then(() => true)
-        .catch(() => false);
-    return tensorsExist;
-}

package/dist/server/utils/tool-integration.d.ts

@@ -1,17 +0,0 @@
-import type { Tool, ToolDialect } from '../../schemas/index.js';
-interface HistoryMessage {
-    role: string;
-    content: string;
-    attachments?: {
-        path: string;
-    }[] | undefined;
-}
-/**
- * Prepend tools right after the system message (or at the very start when no
- * system message is present). The tool block stays in the kv-cache for the
- * whole chat session.
- */
-export declare function prependToolsToHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
-export declare function detectToolDialect(modelId: string): ToolDialect;
-export {};
-//# sourceMappingURL=tool-integration.d.ts.map

package/dist/server/utils/tool-integration.js

@@ -1,20 +0,0 @@
-import { detectToolDialectFromName } from '../../server/utils/tools/index.js';
-import { getModelInfo } from '../../server/bare/registry/model-registry.js';
-/**
- * Prepend tools right after the system message (or at the very start when no
- * system message is present). The tool block stays in the kv-cache for the
- * whole chat session.
- */
-export function prependToolsToHistory(history, tools) {
-    const systemMsgIndex = history.findIndex((msg) => msg.role === 'system');
-    if (systemMsgIndex >= 0) {
-        return [...history.slice(0, systemMsgIndex + 1), ...tools, ...history.slice(systemMsgIndex + 1)];
-    }
-    return [...tools, ...history];
-}
-export function detectToolDialect(modelId) {
-    const info = getModelInfo(modelId);
-    if (!info)
-        return 'hermes';
-    return detectToolDialectFromName(info.name, info.path);
-}

package/dist/server/utils/tools/dialect.d.ts

@@ -1,8 +0,0 @@
-import type { ToolDialect } from '../../../schemas/index.js';
-/**
- * Detects the tool-call dialect from a model's registry name and file path.
- * Defaults to "hermes" (its parser chain also covers unknown JSON-payload
- * models). Bypass with `completion({ toolDialect })`.
- */
-export declare function detectToolDialectFromName(name: string | undefined, path: string): ToolDialect;
-//# sourceMappingURL=dialect.d.ts.map