@qvac/sdk 0.5.0 → 0.6.0

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

@@ -0,0 +1,314 @@
+import { promises as fsPromises, createReadStream } from "bare-fs";
+import path from "bare-path";
+import { getServerLogger } from "../../logging/index.js";
+import { ModelLoadFailedError } from "../../utils/errors-server.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 = path.join(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 = path.join(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,8 +1,10 @@
+export * from "./archive";
 export * from "./audio/decoder";
 export * from "./cache";
 export * from "./checksum";
 export * from "./config-transform";
-export * from "./hash";
+export * from "./formatting";
+export * from "./gguf-tensor-extractor";
 export * from "./model-path";
 export * from "./shard-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,7 +1,9 @@
+export * from "./archive.js";
 export * from "./audio/decoder.js";
 export * from "./cache.js";
 export * from "./checksum.js";
 export * from "./config-transform.js";
-export * from "./hash.js";
+export * from "./formatting.js";
+export * from "./gguf-tensor-extractor.js";
 export * from "./model-path.js";
 export * from "./shard-utils.js";

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

@@ -1,22 +1,48 @@
-export interface ShardInfo {
-    isSharded: boolean;
-    currentShard?: number;
-    totalShards?: number;
-    baseFilename?: string;
-    extension?: string;
-}
-export interface ShardMetadata {
-    filename: string;
-    expectedSize: number;
-    sha256Checksum: string;
-}
+import type { ShardPatternInfo, ShardUrl } from "../../schemas/index";
 /**
  * Detect if model filename follows shard pattern (00001-of-0000x)
  */
-export declare function detectShardedModel(filename: string): ShardInfo;
+export declare function detectShardedModel(filename: string): ShardPatternInfo;
 /**
- * Generate list of all required files for a sharded model
- * Includes numbered shards AND the .tensors.txt companion file
+ * 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(firstShardName: string): string[];
+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,4 +1,8 @@
-import { ModelLoadFailedError } from "../../utils/errors-server.js";
+import { ModelLoadFailedError, InvalidShardUrlPatternError, } from "../../utils/errors-server.js";
+import { generateShortHash } from "./formatting.js";
+import { extractAndWriteTensorsFile } from "./gguf-tensor-extractor.js";
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
 /**
  * Detect if model filename follows shard pattern (00001-of-0000x)
  */
@@ -17,13 +21,16 @@ export function detectShardedModel(filename) {
     return { isSharded: false };
 }
 /**
- * Generate list of all required files for a sharded model
- * Includes numbered shards AND the .tensors.txt companion file
+ * 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(firstShardName) {
-    const shardInfo = detectShardedModel(firstShardName);
+export function generateShardFilenames(shardName) {
+    const shardInfo = detectShardedModel(shardName);
     if (!shardInfo.isSharded || !shardInfo.totalShards) {
-        throw new ModelLoadFailedError(`Not a sharded model filename: ${firstShardName}`);
+        throw new ModelLoadFailedError(`Not a sharded model filename: ${shardName}`);
     }
     const filenames = [];
     const { baseFilename, totalShards, extension } = shardInfo;
@@ -32,6 +39,87 @@ export function generateShardFilenames(firstShardName) {
         const totalShardsStr = totalShards.toString().padStart(5, "0");
         filenames.push(`${baseFilename}-${shardNumber}-of-${totalShardsStr}${extension}`);
     }
-    filenames.push(`${baseFilename}.tensors.txt`);
     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(path.join(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(path.join(shardDir, tensorsFile))
+        .then(() => true)
+        .catch(() => false);
+    return tensorsExist;
+}

package/dist/server/worker.js

@@ -1,8 +1,9 @@
 import process from "bare-process";
+import { isBareKit } from "which-runtime";
 import { createBareKitRPCServer, createIPCClient, } from "./rpc/create-server.js";
 import { z } from "zod";
 import { destroySwarm } from "./bare/hyperswarm.js";
-import { closeAllRagInstances } from "./bare/rag-hyperdb/rag-manager.js";
+import { closeAllRagInstances } from "./bare/rag-hyperdb/index.js";
 import { cleanupDownloads } from "./rpc/handlers/load-model/download-manager.js";
 import { unloadAllModels } from "./bare/registry/model-registry.js";
 import { clearAllLoggingStreams, startLogBuffering, } from "./bare/registry/logging-stream-registry.js";
@@ -26,6 +27,10 @@ nmtAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.NMTCPP));
 const defaultHomeDir = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
 let envConfig = { HOME_DIR: defaultHomeDir };
 let hasRPCConfig = false;
+if (isBareKit && process.argv[0]) {
+    logger.info("Running in BareKit mode");
+    envConfig["HOME_DIR"] = process.argv[0];
+}
 // Try to parse any argument as JSON config (fail gracefully)
 if (process.argv[2]) {
     try {
@@ -96,7 +101,7 @@ function clearLoggers() {
 }
 // Centralized cleanup for graceful shutdown
 let isShuttingDown = false;
-const shutdownHandler = async () => {
+async function shutdownHandler() {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
@@ -115,6 +120,6 @@ const shutdownHandler = async () => {
         logger.error("❌ Error during shutdown cleanup:", error);
     }
     process.exit(0);
-};
+}
 process.once("SIGTERM", () => void shutdownHandler());
 process.once("SIGINT", () => void shutdownHandler());

package/dist/utils/errors-base.d.ts

@@ -1,3 +1,3 @@
 import type { QvacErrorOptions } from "@qvac/error";
-export declare const createErrorOptions: (code: number, adds?: string | (string | number)[], cause?: unknown) => QvacErrorOptions;
+export declare function createErrorOptions(code: number, adds?: string | (string | number)[], cause?: unknown): QvacErrorOptions;
 //# sourceMappingURL=errors-base.d.ts.map

package/dist/utils/errors-base.js

@@ -1,4 +1,4 @@
-export const createErrorOptions = (code, adds, cause) => {
+export function createErrorOptions(code, adds, cause) {
     const options = { code };
     if (adds !== undefined) {
         options.adds = adds;
@@ -10,4 +10,4 @@ export const createErrorOptions = (code, adds, cause) => {
                 : new Error(typeof cause === "string" ? cause : JSON.stringify(cause));
     }
     return options;
-};
+}

package/dist/utils/errors-client.d.ts

@@ -20,6 +20,9 @@ export declare class InvalidToolsArrayError extends QvacErrorBase {
 export declare class InvalidToolSchemaError extends QvacErrorBase {
     constructor(details: string, cause?: unknown);
 }
+export declare class OCRFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class RPCNoHandlerError extends QvacErrorBase {
     constructor(requestType: string, cause?: unknown);
 }
@@ -83,6 +86,9 @@ export declare class TranslationFailedError extends QvacErrorBase {
 export declare class CancelFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class RAGChunkFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class RAGSaveFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -92,6 +98,12 @@ export declare class RAGSearchFailedError extends QvacErrorBase {
 export declare class RAGDeleteFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class RAGCloseWorkspaceFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class RAGListWorkspacesFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
 export declare class DownloadAssetFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -37,6 +37,11 @@ export class InvalidToolSchemaError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_TOOL_SCHEMA, [details], cause));
     }
 }
+export class OCRFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.OCR_FAILED, details ? [details] : undefined, cause));
+    }
+}
 // ============== RPC Communication Errors ==============
 export class RPCNoHandlerError extends QvacErrorBase {
     constructor(requestType, cause) {
@@ -149,6 +154,11 @@ export class CancelFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CANCEL_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class RAGChunkFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_CHUNK_FAILED, details ? [details] : undefined, cause));
+    }
+}
 export class RAGSaveFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_SAVE_FAILED, details ? [details] : undefined, cause));
@@ -164,6 +174,16 @@ export class RAGDeleteFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_DELETE_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class RAGCloseWorkspaceFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_CLOSE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGListWorkspacesFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_LIST_WORKSPACES_FAILED, details ? [details] : undefined, cause));
+    }
+}
 export class DownloadAssetFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.DOWNLOAD_ASSET_FAILED, details ? [details] : undefined, cause));