@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/utils/archive.js

@@ -1,28 +1,28 @@
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import fs from "bare-fs";
-import { createGunzip } from "bare-zlib";
-import tarStream from "tar-stream";
-import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache, } from "./shard-utils.js";
-import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError, } from "../../utils/errors-server.js";
-import { isPathWithinBase } from "./path-security.js";
-import { getServerLogger } from "../../logging/index.js";
-import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema, } from "../../schemas/archive.js";
+import { promises as fsPromises } from 'bare-fs';
+import path from 'bare-path';
+import fs from 'bare-fs';
+import { createGunzip } from 'bare-zlib';
+import tarStream from 'tar-stream';
+import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache } from './shard-utils.js';
+import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError } from '../../utils/errors-server.js';
+import { isPathWithinBase } from './path-security.js';
+import { getServerLogger } from '../../logging/index.js';
+import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema } from '../../schemas/archive.js';
 const logger = getServerLogger();
 // Gzip magic bytes: 1f 8b 08
 const GZIP_MAGIC_0 = 0x1f;
 const GZIP_MAGIC_1 = 0x8b;
 const GZIP_MAGIC_2 = 0x08;
 export function isArchiveUrl(url) {
-    const filename = url.split("/").pop()?.split("?")[0]?.toLowerCase() || "";
+    const filename = url.split('/').pop()?.split('?')[0]?.toLowerCase() || '';
     return SUPPORTED_ARCHIVE_EXTENSIONS.some((ext) => filename.endsWith(ext));
 }
 // Whitelist of model file extensions to extract from archives
-const ALLOWED_MODEL_EXTENSIONS = [".gguf", ".tensors.txt"];
+const ALLOWED_MODEL_EXTENSIONS = ['.gguf', '.tensors.txt'];
 function isModelFile(entryName) {
     const basename = path.basename(entryName);
     // Skip resource forks (._filename)
-    if (basename.startsWith("._")) {
+    if (basename.startsWith('._')) {
         return false;
     }
     return ALLOWED_MODEL_EXTENSIONS.some((ext) => basename.toLowerCase().endsWith(ext));
@@ -31,19 +31,17 @@ async function isGzip(archivePath) {
     return new Promise((resolve, reject) => {
         const stream = fs.createReadStream(archivePath, { start: 0, end: 2 });
         const chunks = [];
-        stream.on("data", (chunk) => {
+        stream.on('data', (chunk) => {
             chunks.push(chunk);
         });
-        stream.on("end", () => {
+        stream.on('end', () => {
             stream.destroy();
             const buffer = Buffer.concat(chunks);
             // Check for gzip magic bytes
-            const isGzipped = buffer[0] === GZIP_MAGIC_0 &&
-                buffer[1] === GZIP_MAGIC_1 &&
-                buffer[2] === GZIP_MAGIC_2;
+            const isGzipped = buffer[0] === GZIP_MAGIC_0 && buffer[1] === GZIP_MAGIC_1 && buffer[2] === GZIP_MAGIC_2;
             resolve(isGzipped);
         });
-        stream.on("error", reject);
+        stream.on('error', reject);
     });
 }
 async function extractArchive(archivePath, extractDir, signal) {
@@ -57,7 +55,7 @@ async function extractArchive(archivePath, extractDir, signal) {
     }
     // Detect actual format from magic bytes (extension might be wrong)
     const isGzipped = await isGzip(archivePath);
-    const actualType = isGzipped ? "tar.gz" : "tar";
+    const actualType = isGzipped ? 'tar.gz' : 'tar';
     if (actualType !== extensionType) {
         logger.warn(`⚠️ Archive extension suggests ${extensionType} but content is ${actualType}`);
     }
@@ -77,12 +75,12 @@ export async function extractTarStream(archivePath, extractDir, useGunzip, signa
             extract.destroy();
         };
         if (signal) {
-            signal.addEventListener("abort", () => {
+            signal.addEventListener('abort', () => {
                 cleanup();
                 reject(new DownloadCancelledError());
             });
         }
-        extract.on("entry", (header, stream, next) => {
+        extract.on('entry', (header, stream, next) => {
             if (aborted) {
                 stream.resume();
                 return;
@@ -100,23 +98,23 @@ export async function extractTarStream(archivePath, extractDir, useGunzip, signa
                 next();
                 return;
             }
-            if (header.type === "file") {
+            if (header.type === 'file') {
                 const dir = path.dirname(filePath);
                 fs.mkdirSync(dir, { recursive: true });
                 const writeStream = fs.createWriteStream(filePath);
                 stream.pipe(writeStream);
-                writeStream.on("finish", next);
-                writeStream.on("error", reject);
+                writeStream.on('finish', next);
+                writeStream.on('error', reject);
             }
             else {
-                stream.on("end", next);
+                stream.on('end', next);
                 stream.resume();
             }
         });
-        extract.on("finish", resolve);
-        extract.on("error", reject);
+        extract.on('finish', resolve);
+        extract.on('error', reject);
         if (gunzip) {
-            gunzip.on("error", reject);
+            gunzip.on('error', reject);
         }
         readStream = fs.createReadStream(archivePath);
         if (gunzip) {

package/dist/server/utils/audio/decoder.d.ts

@@ -1,5 +1,5 @@
-import { Readable } from "bare-stream";
-import { type AudioFormat } from "../../../schemas/index";
+import { Readable } from 'bare-stream';
+import { type AudioFormat } from '../../../schemas/index';
 export declare function needsDecoding(filePath: string): boolean;
 export declare function decodeAudioToStream(inputPath: string, audioFormat?: AudioFormat): Promise<Readable>;
 //# sourceMappingURL=decoder.d.ts.map

package/dist/server/utils/audio/decoder.js

@@ -1,27 +1,27 @@
-import fs from "bare-fs";
-import path from "bare-path";
-import { FFmpegDecoder } from "@qvac/decoder-audio";
-import { FORMATS_NEEDING_DECODE } from "@qvac/decoder-audio/constants.js";
-import { Readable } from "bare-stream";
-import { getServerLogger } from "../../../logging/index.js";
-import {} from "../../../schemas/index.js";
+import fs from 'bare-fs';
+import path from 'bare-path';
+import { FFmpegDecoder } from '@qvac/decoder-audio';
+import { FORMATS_NEEDING_DECODE } from '@qvac/decoder-audio/constants.js';
+import { Readable } from 'bare-stream';
+import { getServerLogger } from '../../../logging/index.js';
+import {} from '../../../schemas/index.js';
 const logger = getServerLogger();
 export function needsDecoding(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return FORMATS_NEEDING_DECODE.includes(ext);
 }
 const DECODER_TIMEOUT_MS = 10000;
-export async function decodeAudioToStream(inputPath, audioFormat = "s16le") {
+export async function decodeAudioToStream(inputPath, audioFormat = 's16le') {
     const decoder = new FFmpegDecoder({
         config: { audioFormat },
-        logger,
+        logger
     });
     try {
         await decoder.load();
         const audioStream = fs.createReadStream(inputPath);
         const response = decoder.run(audioStream);
         const outputStream = new Readable({
-            read() { },
+            read() { }
         });
         let hasReceivedData = false;
         let hasEnded = false;
@@ -72,7 +72,7 @@ export async function decodeAudioToStream(inputPath, audioFormat = "s16le") {
     }
     catch (error) {
         await decoder.unload();
-        logger.error("Decoding failed:", error instanceof Error ? error.message : String(error));
+        logger.error('Decoding failed:', error instanceof Error ? error.message : String(error));
         throw error;
     }
 }

package/dist/server/utils/cache/auto-history.d.ts

@@ -1,4 +1,4 @@
-import type { CacheMessage } from "./types";
+import type { CacheMessage } from './types';
 export declare function getAutoCacheLookupHistory(currentHistory: CacheMessage[]): CacheMessage[];
 export declare function buildAutoCacheSaveHistory(currentHistory: CacheMessage[], assistantResponse: string): CacheMessage[];
 //# sourceMappingURL=auto-history.d.ts.map

package/dist/server/utils/cache/auto-history.js

@@ -1,22 +1,26 @@
-import { normalizeAssistantCacheContent } from "../../../utils/cache-normalize.js";
-function normalizeAssistantMessage(message) {
-    if (message.role !== "assistant") {
-        return message;
+import { normalizeAssistantCacheContent } from '../../../utils/cache-normalize.js';
+function normalizeCacheMessage(message) {
+    const { attachments, ...normalized } = message;
+    if (message.role === 'assistant') {
+        normalized.content = normalizeAssistantCacheContent(message.content);
     }
-    return { ...message, content: normalizeAssistantCacheContent(message.content) };
+    return {
+        ...normalized,
+        ...(attachments && attachments.length > 0 ? { attachments } : {})
+    };
 }
 export function getAutoCacheLookupHistory(currentHistory) {
     if (currentHistory.length <= 1) {
         return [];
     }
-    return currentHistory.slice(0, -1).map(normalizeAssistantMessage);
+    return currentHistory.slice(0, -1).map(normalizeCacheMessage);
 }
 export function buildAutoCacheSaveHistory(currentHistory, assistantResponse) {
     return [
-        ...currentHistory,
-        {
-            role: "assistant",
-            content: normalizeAssistantCacheContent(assistantResponse),
-        },
+        ...currentHistory.map(normalizeCacheMessage),
+        normalizeCacheMessage({
+            role: 'assistant',
+            content: assistantResponse
+        })
     ];
 }

package/dist/server/utils/cache/paths.d.ts

@@ -1,4 +1,4 @@
-import type { ShardFileMetadata } from "../../../schemas/index";
+import type { ShardFileMetadata } from '../../../schemas/index';
 export declare function getCacheDir(subDir: string): string;
 export declare function getModelsCacheDir(): string;
 export declare function getKVCacheDir(): string;
@@ -32,7 +32,7 @@ export declare function getShardPath(hyperdriveKey: string, shardFilename: strin
  */
 export declare function getClearStorageTarget(modelPath: string): {
     path: string;
-    kind: "file" | "directory";
+    kind: 'file' | 'directory';
 };
 /**
  * Check if all shards exist and are valid (size + checksum check)

package/dist/server/utils/cache/paths.js

@@ -1,13 +1,13 @@
-import fs, { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { getConfiguredCacheDir } from "../../bare/registry/config-registry.js";
-import { getQvacPath } from "../qvac-paths.js";
-import { calculateFileChecksum } from "../checksum.js";
-import { validateAndJoinPath } from "../path-security.js";
-import { generateShortHash } from "../formatting.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { nowMs } from "../../../profiling/index.js";
-import { resolveClearStorageTarget } from "../clear-storage.js";
+import fs, { promises as fsPromises } from 'bare-fs';
+import path from 'bare-path';
+import { getConfiguredCacheDir } from '../../bare/registry/config-registry.js';
+import { getQvacPath } from '../qvac-paths.js';
+import { calculateFileChecksum } from '../checksum.js';
+import { validateAndJoinPath } from '../path-security.js';
+import { generateShortHash } from '../formatting.js';
+import { getServerLogger } from '../../../logging/index.js';
+import { nowMs } from '../../../profiling/index.js';
+import { resolveClearStorageTarget } from '../clear-storage.js';
 const logger = getServerLogger();
 export function getCacheDir(subDir) {
     const cacheDir = getQvacPath(subDir);
@@ -30,7 +30,7 @@ export function getModelsCacheDir() {
     return configuredDir;
 }
 export function getKVCacheDir() {
-    return getCacheDir("kv-cache");
+    return getCacheDir('kv-cache');
 }
 /**
  * Get cache directory for sharded model
@@ -38,7 +38,7 @@ export function getKVCacheDir() {
  */
 export function getShardedModelCacheDir(hyperdriveKey) {
     const baseCache = getModelsCacheDir();
-    const shardDir = path.join(baseCache, "sharded", hyperdriveKey);
+    const shardDir = path.join(baseCache, 'sharded', hyperdriveKey);
     try {
         fs.mkdirSync(shardDir, { recursive: true });
     }
@@ -53,7 +53,7 @@ export function getShardedModelCacheDir(hyperdriveKey) {
  */
 export function getCompanionSetCacheDir(setKey) {
     const baseCache = getModelsCacheDir();
-    const setDir = validateAndJoinPath(baseCache, "sets", setKey);
+    const setDir = validateAndJoinPath(baseCache, 'sets', setKey);
     try {
         fs.mkdirSync(setDir, { recursive: true });
     }
@@ -74,7 +74,7 @@ export function getCompanionSetPath(setKey, targetName) {
  * Get cache path for a single (non-sharded, non-companion) registry model.
  */
 export function getSingleFileCachePath(registryPath) {
-    const filename = registryPath.split("/").pop() || registryPath;
+    const filename = registryPath.split('/').pop() || registryPath;
     const sourceHash = generateShortHash(registryPath);
     return path.join(getModelsCacheDir(), `${sourceHash}_${filename}`);
 }

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

@@ -1,4 +1,4 @@
-import type { DownloadHooks } from "../rpc/handlers/load-model/types";
+import type { DownloadHooks } from '../rpc/handlers/load-model/types';
 export declare function calculateFileChecksum(filePath: string): Promise<string>;
 export declare function measureChecksum(filePath: string, hooks?: DownloadHooks): Promise<string>;
 //# sourceMappingURL=checksum.d.ts.map

package/dist/server/utils/checksum.js

@@ -1,26 +1,24 @@
-import fs from "bare-fs";
-import crypto from "bare-crypto";
-import { nowMs } from "../../profiling/index.js";
-import {} from "bare-buffer";
+import fs from 'bare-fs';
+import crypto from 'bare-crypto';
+import { nowMs } from '../../profiling/index.js';
+import {} from 'bare-buffer';
 export async function calculateFileChecksum(filePath) {
     return new Promise((resolve, reject) => {
         try {
-            const hash = crypto.createHash("sha-256");
+            const hash = crypto.createHash('sha-256');
             const stream = fs.createReadStream(filePath);
-            stream.on("data", (chunk) => {
+            stream.on('data', (chunk) => {
                 hash.update(chunk);
             });
-            stream.on("end", () => {
-                resolve(hash.digest("hex"));
+            stream.on('end', () => {
+                resolve(hash.digest('hex'));
             });
-            stream.on("error", (error) => {
+            stream.on('error', (error) => {
                 reject(new Error(`Checksum calculation error: ${error.message}`));
             });
         }
         catch (error) {
-            reject(error instanceof Error
-                ? error
-                : new Error(`Checksum calculation error: ${String(error)}`));
+            reject(error instanceof Error ? error : new Error(`Checksum calculation error: ${String(error)}`));
         }
     });
 }

package/dist/server/utils/clear-storage.d.ts

@@ -1,5 +1,5 @@
 export declare function resolveClearStorageTarget(modelPath: string, modelsCacheDir: string): {
     path: string;
-    kind: "file" | "directory";
+    kind: 'file' | 'directory';
 };
 //# sourceMappingURL=clear-storage.d.ts.map

package/dist/server/utils/clear-storage.js

@@ -1,17 +1,14 @@
 export function resolveClearStorageTarget(modelPath, modelsCacheDir) {
-    const normalizedCache = modelsCacheDir.replace(/\\/g, "/").replace(/\/+$/, "");
-    const normalizedPath = modelPath.replace(/\\/g, "/");
+    const normalizedCache = modelsCacheDir.replace(/\\/g, '/').replace(/\/+$/, '');
+    const normalizedPath = modelPath.replace(/\\/g, '/');
     if (!normalizedPath.startsWith(`${normalizedCache}/`)) {
-        return { path: modelPath, kind: "file" };
+        return { path: modelPath, kind: 'file' };
     }
     const relativePath = normalizedPath.slice(normalizedCache.length + 1);
-    const parts = relativePath.split("/");
-    if (parts.length === 3 &&
-        (parts[0] === "sets" || parts[0] === "onnx") &&
-        parts[1] &&
-        parts[2]) {
-        const lastSlash = normalizedPath.lastIndexOf("/");
-        return { path: normalizedPath.slice(0, lastSlash), kind: "directory" };
+    const parts = relativePath.split('/');
+    if (parts.length === 3 && (parts[0] === 'sets' || parts[0] === 'onnx') && parts[1] && parts[2]) {
+        const lastSlash = normalizedPath.lastIndexOf('/');
+        return { path: normalizedPath.slice(0, lastSlash), kind: 'directory' };
     }
-    return { path: modelPath, kind: "file" };
+    return { path: modelPath, kind: 'file' };
 }

package/dist/server/utils/completion-normalizer.d.ts

@@ -1,4 +1,4 @@
-import type { CompletionEvent, CompletionError, CompletionStats, NormalizerConfig, StopReason, ToolCall } from "../../schemas/index";
+import type { CompletionEvent, CompletionError, CompletionStats, NormalizerConfig, StopReason, ToolCall } from '../../schemas/index';
 export type CompletionNormalizer = ReturnType<typeof createCompletionNormalizer>;
 export declare function createCompletionNormalizer(config: NormalizerConfig): {
     push: (token: string) => CompletionEvent[];