@qvac/sdk 0.8.0 → 1.0.0

package/dist/server/utils/config-transform.js

@@ -1,23 +0,0 @@
-import { normalizeModelType, ModelType, } from "../../schemas/index.js";
-export function transformConfigForReload(modelType, config) {
-    const canonicalType = normalizeModelType(modelType);
-    switch (canonicalType) {
-        case ModelType.whispercppTranscription: {
-            const whisperConfig = config;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
-            return {
-                whisperConfig: whisperParams,
-                ...(miscConfig && { miscConfig }),
-            };
-        }
-        case ModelType.llamacppCompletion:
-        case ModelType.llamacppEmbedding:
-        case ModelType.nmtcppTranslation:
-        case ModelType.onnxTts:
-            // Return as-is for now
-            return config;
-        default:
-            return config;
-    }
-}

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

@@ -1,19 +0,0 @@
-/**
- * Generate a short hash (16 characters) from any input string
- */
-export declare function generateShortHash(input: string): string;
-/**
- * Create a stable, deterministic string representation of a config object.
- * - Recursively sorts all object keys
- * - Normalizes ModelDescriptor objects to their src string
- */
-export declare function canonicalConfigString(config: Record<string, unknown> | undefined): string;
-/**
- * Calculate progress percentage with bounds checking and consistent formatting
- * @param current - Current progress value
- * @param total - Total value
- * @param decimals - Number of decimal places (default: 2)
- * @returns Percentage clamped between 0-100 with fixed decimal places
- */
-export declare function calculatePercentage(current: number, total: number, decimals?: number): number;
-//# sourceMappingURL=formatting.d.ts.map

package/dist/server/utils/formatting.js

@@ -1,61 +0,0 @@
-import crypto from "bare-crypto";
-/**
- * Generate a short hash (16 characters) from any input string
- */
-export function generateShortHash(input) {
-    const hash = crypto
-        .createHash("sha256")
-        .update(Buffer.from(input, "utf8"))
-        .digest("hex");
-    return hash.substring(0, 16);
-}
-function isModelDescriptor(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "src" in value &&
-        typeof value.src === "string");
-}
-function normalizeValue(value) {
-    if (isModelDescriptor(value)) {
-        return value.src;
-    }
-    if (Array.isArray(value)) {
-        return value.map(normalizeValue);
-    }
-    if (typeof value === "object" && value !== null) {
-        return normalizeConfig(value);
-    }
-    return value;
-}
-function normalizeConfig(config) {
-    const result = {};
-    for (const key of Object.keys(config).sort()) {
-        result[key] = normalizeValue(config[key]);
-    }
-    return result;
-}
-/**
- * Create a stable, deterministic string representation of a config object.
- * - Recursively sorts all object keys
- * - Normalizes ModelDescriptor objects to their src string
- */
-export function canonicalConfigString(config) {
-    if (!config)
-        return "{}";
-    return JSON.stringify(normalizeConfig(config));
-}
-/**
- * Calculate progress percentage with bounds checking and consistent formatting
- * @param current - Current progress value
- * @param total - Total value
- * @param decimals - Number of decimal places (default: 2)
- * @returns Percentage clamped between 0-100 with fixed decimal places
- */
-export function calculatePercentage(current, total, decimals = 2) {
-    if (total <= 0 || current < 0) {
-        return 0;
-    }
-    const rawPercentage = (current / total) * 100;
-    const clampedPercentage = Math.min(Math.max(rawPercentage, 0), 100);
-    return Number(clampedPercentage.toFixed(decimals));
-}

package/dist/server/utils/gguf-tensor-extractor.d.ts

@@ -1,15 +0,0 @@
-/**
- * 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 declare function extractAndWriteTensorsFile(shardDir: string, shardFilenames: string[], baseFilename: string): Promise<string>;
-/**
- * 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 declare function hasValidGGUFHeader(filePath: string): Promise<boolean>;
-//# sourceMappingURL=gguf-tensor-extractor.d.ts.map

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

@@ -1,314 +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.currentOffset = currentOffset;
-        this.bytesNeeded = bytesNeeded;
-        this.name = "NeedMoreDataError";
-    }
-}
-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/path-security.d.ts

@@ -1,12 +0,0 @@
-export { sanitizePathComponent } from "../../utils/path-sanitize";
-/**
- * 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, path.resolve, 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/shard-utils.d.ts

@@ -1,48 +0,0 @@
-import type { ShardPatternInfo, ShardUrl } from "../../schemas/index";
-/**
- * Detect if model filename follows shard pattern (00001-of-0000x)
- */
-export declare function detectShardedModel(filename: string): ShardPatternInfo;
-/**
- * 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,125 +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 };
-}
-/**
- * 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,13 +0,0 @@
-import type { Tool, ToolCallEvent } from "../../schemas/index";
-interface HistoryMessage {
-    role: string;
-    content: string;
-    attachments?: {
-        path: string;
-    }[] | undefined;
-}
-export declare function insertToolsIntoHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
-export declare function setupToolGrammar(modelConfig: Record<string, unknown>, tools: Tool[]): void;
-export declare function checkForToolEvents(accumulatedText: string, currentToken: string, tools: Tool[], emittedToolCallPositions: Set<number>): ToolCallEvent[];
-export {};
-//# sourceMappingURL=tool-integration.d.ts.map