@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/utils/completion-normalizer.js

@@ -1,453 +0,0 @@
-import { parseToolCalls } from '../../server/utils/tools/index.js';
-export const MAX_TOOL_FRAME_CHARS = 1_048_576;
-const DSML_INVOKE_FRAMES = [' ', '\n', '\t', '\r'].map((sep) => ({
-    open: `<｜DSML｜invoke${sep}`,
-    close: '</｜DSML｜invoke>'
-}));
-const DIALECT_SPECS = {
-    hermes: {
-        toolFrames: [{ open: '<tool_call>', close: '</tool_call>' }]
-    },
-    // No streaming framing — tool calls are only recovered at finalization.
-    json: {
-        toolFrames: []
-    },
-    pythonic: {
-        toolFrames: [
-            { open: '<|tool_call_start|>', close: '<|tool_call_end|>' },
-            {
-                open: '<|start_header_id|>tool_call<|end_header_id|>',
-                close: '<|eot_id|>'
-            }
-        ]
-    },
-    harmony: {
-        toolFrames: [{ open: '<|channel|>commentary to=functions.', close: '<|call|>' }],
-        thinkingFrames: [{ open: '<|channel|>analysis<|message|>', close: '<|end|>' }],
-        contentFrames: [
-            { open: '<|channel|>final<|message|>', close: '<|return|>' },
-            { open: '<|channel|>assistant<|message|>', close: '<|end|>' }
-        ],
-        // Role headers and stray Harmony control tokens between frames.
-        dropTokens: [
-            '<|message|>',
-            '<|end|>',
-            '<|start|>assistant',
-            '<|start|>system',
-            '<|start|>user',
-            '<|return|>'
-        ],
-        contentDropTokens: ['<|channel|>']
-    },
-    qwen35: {
-        // Same <tool_call>…</tool_call> framing as hermes; inner content is XML.
-        toolFrames: [{ open: '<tool_call>', close: '</tool_call>' }]
-    },
-    gemma4: {
-        toolFrames: [{ open: '<|tool_call>', close: '<tool_call|>' }],
-        thinkingFrames: [{ open: '<|channel>thought', close: '<channel|>' }]
-    },
-    dsml: {
-        toolFrames: [
-            { open: '<｜DSML｜tool_calls>', close: '</｜DSML｜tool_calls>' },
-            { open: '<｜DSML｜function_calls>', close: '</｜DSML｜function_calls>' },
-            ...DSML_INVOKE_FRAMES
-        ]
-    }
-};
-// Capture-gated reasoning marker — the generic `<think>...</think>`
-// convention used by reasoning-tuned models. When the gate is off the
-// markers pass through into `contentDelta` unchanged (preserves the
-// pre-dialect behavior).
-const BUILTIN_THINKING = { open: '<think>', close: '</think>' };
-export function createCompletionNormalizer(config) {
-    let seq = 0;
-    let state = 'content';
-    let rawText = '';
-    const contentParts = [];
-    const thinkingParts = [];
-    // Tool frame: buffer keeps the open + close markers in place so
-    // `parseToolCalls` can match its own dialect markers.
-    let toolCallBuffer = '';
-    let activeToolFrame = null;
-    // Thinking frame: tracks which frame's close marker we're scanning for
-    // (could be the built-in `<think>` or a dialect-specific frame like
-    // Harmony's `<|channel|>analysis<|message|>...<|end|>`).
-    let activeThinkingFrame = null;
-    // Content frame: inner streamed as it arrives; partial close tail buffered.
-    let activeContentFrame = null;
-    // Trailing chars that could be a prefix of a watched marker, so markers
-    // split across token pushes aren't missed by indexOf.
-    let contentTail = '';
-    let toolFramingTail = '';
-    let thinkingFramingTail = '';
-    let contentFramingTail = '';
-    const streamedToolCallKeys = new Set();
-    const toolsEnabled = config.tools.length > 0 && config.capabilities.toolCalling !== 'none';
-    const useToolFraming = toolsEnabled && config.capabilities.toolCalling === 'textParse';
-    // Register `<think>` only when both capability + capture opt in.
-    // Dialect protocol markers always register; capture only gates emission.
-    const useBuiltinThinkTags = config.captureThinking && config.capabilities.thinkingFraming === 'thinkTags';
-    const dialect = config.toolDialect ?? 'hermes';
-    const dialectSpec = DIALECT_SPECS[dialect];
-    const toolFrames = useToolFraming ? dialectSpec.toolFrames : [];
-    const thinkingFrames = [
-        ...(useBuiltinThinkTags ? [BUILTIN_THINKING] : []),
-        ...(dialectSpec.thinkingFrames ?? [])
-    ];
-    const contentFrames = dialectSpec.contentFrames ?? [];
-    const dropTokens = dialectSpec.dropTokens ?? [];
-    const contentDropTokens = dialectSpec.contentDropTokens ?? [];
-    const markerToEntry = new Map();
-    const dropTokenSet = new Set();
-    const contentMarkers = [];
-    function registerFrames(frames, kind) {
-        for (const f of frames) {
-            if (markerToEntry.has(f.open))
-                continue;
-            markerToEntry.set(f.open, { kind, spec: f });
-            contentMarkers.push(f.open);
-        }
-    }
-    registerFrames(toolFrames, 'tool');
-    registerFrames(thinkingFrames, 'thinking');
-    registerFrames(contentFrames, 'content');
-    for (const t of dropTokens) {
-        if (markerToEntry.has(t) || dropTokenSet.has(t))
-            continue;
-        dropTokenSet.add(t);
-        contentMarkers.push(t);
-    }
-    function nextSeq() {
-        return seq++;
-    }
-    function emitContent(events, text) {
-        let normalized = text;
-        for (const token of contentDropTokens) {
-            normalized = normalized.split(token).join('');
-        }
-        if (!normalized)
-            return;
-        contentParts.push(normalized);
-        events.push({ type: 'contentDelta', seq: nextSeq(), text: normalized });
-    }
-    // Capture-gated: thinking frames may register even when `captureThinking`
-    // is false (e.g. harmony's analysis channel, to strip markers from
-    // `contentDelta`) — drop the inner here instead of buffering it.
-    function emitThinking(events, text) {
-        if (!text)
-            return;
-        if (config.captureThinking) {
-            thinkingParts.push(text);
-            events.push({ type: 'thinkingDelta', seq: nextSeq(), text });
-        }
-    }
-    function getToolCallKey(call) {
-        return `${call.name}:${JSON.stringify(call.arguments)}`;
-    }
-    function emitStreamedToolCall(events, call) {
-        streamedToolCallKeys.add(getToolCallKey(call));
-        events.push({ type: 'toolCall', seq: nextSeq(), call });
-    }
-    function emitFinalToolCall(events, call) {
-        if (streamedToolCallKeys.has(getToolCallKey(call)))
-            return;
-        events.push({ type: 'toolCall', seq: nextSeq(), call });
-    }
-    // Length of the longest suffix of `buf` that is also a prefix of any marker.
-    function trailingPartialMarkerLen(buf, markers) {
-        if (markers.length === 0 || buf.length === 0)
-            return 0;
-        const maxLen = Math.min(buf.length, markers.reduce((m, s) => Math.max(m, s.length), 0) - 1);
-        for (let len = maxLen; len > 0; len--) {
-            const suffix = buf.slice(buf.length - len);
-            for (const m of markers) {
-                if (m.startsWith(suffix))
-                    return len;
-            }
-        }
-        return 0;
-    }
-    function findEarliestMarker(buf, markers) {
-        let best = null;
-        for (const m of markers) {
-            const i = buf.indexOf(m);
-            if (i < 0)
-                continue;
-            if (best === null || i < best.idx)
-                best = { idx: i, marker: m };
-        }
-        return best;
-    }
-    function flushToolBuffer(events, closed) {
-        const raw = toolCallBuffer;
-        const frame = activeToolFrame;
-        toolCallBuffer = '';
-        activeToolFrame = null;
-        toolFramingTail = '';
-        if (!frame)
-            return;
-        // Empty-payload guard. Strip frame markers and check the inner is
-        // non-empty; surface a toolError on empty payloads so the literal
-        // markers don't leak into contentDelta.
-        let inner = raw;
-        if (inner.startsWith(frame.open))
-            inner = inner.slice(frame.open.length);
-        if (inner.endsWith(frame.close)) {
-            inner = inner.slice(0, inner.length - frame.close.length);
-        }
-        if (inner.trim().length === 0) {
-            events.push({
-                type: 'toolError',
-                seq: nextSeq(),
-                error: { code: 'PARSE_ERROR', message: 'Empty tool_call frame' }
-            });
-            return;
-        }
-        const { toolCalls, errors } = parseToolCalls(raw, config.tools, dialect);
-        for (const call of toolCalls)
-            emitStreamedToolCall(events, call);
-        if (toolCalls.length === 0) {
-            if (errors.length > 0) {
-                for (const error of errors) {
-                    events.push({ type: 'toolError', seq: nextSeq(), error });
-                }
-            }
-            else {
-                events.push({
-                    type: 'toolError',
-                    seq: nextSeq(),
-                    error: {
-                        code: 'PARSE_ERROR',
-                        message: closed
-                            ? 'Failed to parse tool call from framed region'
-                            : 'Incomplete tool call frame at stream end',
-                        raw
-                    }
-                });
-            }
-            emitContent(events, raw);
-        }
-    }
-    function abandonToolFrame(events) {
-        const raw = toolCallBuffer + toolFramingTail;
-        toolCallBuffer = '';
-        toolFramingTail = '';
-        activeToolFrame = null;
-        state = 'content';
-        events.push({
-            type: 'toolError',
-            seq: nextSeq(),
-            error: {
-                code: 'PARSE_ERROR',
-                message: `Tool call frame exceeded ${MAX_TOOL_FRAME_CHARS} characters without a close marker`
-            }
-        });
-        emitContent(events, raw);
-    }
-    function getStateTail() {
-        switch (state) {
-            case 'content':
-                return contentTail;
-            case 'thinkingFraming':
-                return thinkingFramingTail;
-            case 'toolFraming':
-                return toolFramingTail;
-            case 'contentFraming':
-                return contentFramingTail;
-        }
-    }
-    function processSegment(events, text) {
-        let buf = getStateTail() + text;
-        contentTail = '';
-        thinkingFramingTail = '';
-        toolFramingTail = '';
-        contentFramingTail = '';
-        while (buf.length > 0) {
-            if (state === 'toolFraming') {
-                if (!activeToolFrame) {
-                    state = 'content';
-                    continue;
-                }
-                const hit = buf.indexOf(activeToolFrame.close);
-                if (hit >= 0) {
-                    toolCallBuffer += buf.slice(0, hit + activeToolFrame.close.length);
-                    buf = buf.slice(hit + activeToolFrame.close.length);
-                    state = 'content';
-                    flushToolBuffer(events, true);
-                    continue;
-                }
-                const tailLen = trailingPartialMarkerLen(buf, [activeToolFrame.close]);
-                const safeLen = buf.length - tailLen;
-                toolCallBuffer += buf.slice(0, safeLen);
-                toolFramingTail = buf.slice(safeLen);
-                buf = '';
-                if (toolCallBuffer.length > MAX_TOOL_FRAME_CHARS)
-                    abandonToolFrame(events);
-                continue;
-            }
-            if (state === 'thinkingFraming') {
-                if (!activeThinkingFrame) {
-                    state = 'content';
-                    continue;
-                }
-                const closeMarker = activeThinkingFrame.close;
-                const closeIdx = buf.indexOf(closeMarker);
-                if (closeIdx >= 0) {
-                    emitThinking(events, buf.slice(0, closeIdx));
-                    buf = buf.slice(closeIdx + closeMarker.length);
-                    activeThinkingFrame = null;
-                    state = 'content';
-                    continue;
-                }
-                const tailLen = trailingPartialMarkerLen(buf, [closeMarker]);
-                const safeLen = buf.length - tailLen;
-                emitThinking(events, buf.slice(0, safeLen));
-                thinkingFramingTail = buf.slice(safeLen);
-                buf = '';
-                continue;
-            }
-            if (state === 'contentFraming') {
-                if (!activeContentFrame) {
-                    state = 'content';
-                    continue;
-                }
-                const closeMarker = activeContentFrame.close;
-                const closeIdx = buf.indexOf(closeMarker);
-                if (closeIdx >= 0) {
-                    emitContent(events, buf.slice(0, closeIdx));
-                    activeContentFrame = null;
-                    contentFramingTail = '';
-                    buf = buf.slice(closeIdx + closeMarker.length);
-                    state = 'content';
-                    continue;
-                }
-                const tailLen = trailingPartialMarkerLen(buf, [closeMarker]);
-                const safeLen = buf.length - tailLen;
-                emitContent(events, buf.slice(0, safeLen));
-                contentFramingTail = buf.slice(safeLen);
-                buf = '';
-                continue;
-            }
-            const hit = findEarliestMarker(buf, contentMarkers);
-            if (hit) {
-                emitContent(events, buf.slice(0, hit.idx));
-                buf = buf.slice(hit.idx + hit.marker.length);
-                if (dropTokenSet.has(hit.marker)) {
-                    // Glue token between frames — strip and stay in content state.
-                    continue;
-                }
-                const entry = markerToEntry.get(hit.marker);
-                if (entry.kind === 'tool') {
-                    toolCallBuffer = hit.marker;
-                    activeToolFrame = entry.spec;
-                    state = 'toolFraming';
-                }
-                else if (entry.kind === 'thinking') {
-                    activeThinkingFrame = entry.spec;
-                    state = 'thinkingFraming';
-                }
-                else {
-                    activeContentFrame = entry.spec;
-                    state = 'contentFraming';
-                }
-                continue;
-            }
-            const tailLen = trailingPartialMarkerLen(buf, contentMarkers);
-            const safeLen = buf.length - tailLen;
-            emitContent(events, buf.slice(0, safeLen));
-            contentTail = buf.slice(safeLen);
-            buf = '';
-        }
-    }
-    function push(token) {
-        const events = [];
-        rawText += token;
-        if (config.emitRawDeltas) {
-            events.push({ type: 'rawDelta', seq: nextSeq(), text: token });
-        }
-        processSegment(events, token);
-        return events;
-    }
-    function finish(opts) {
-        const events = [];
-        // Drain pending tail bytes so we don't lose trailing chars when the
-        // stream ends mid-marker.
-        if (state === 'content' && contentTail) {
-            emitContent(events, contentTail);
-            contentTail = '';
-        }
-        else if (state === 'thinkingFraming' && thinkingFramingTail) {
-            emitThinking(events, thinkingFramingTail);
-            thinkingFramingTail = '';
-        }
-        else if (state === 'toolFraming' && toolFramingTail) {
-            toolCallBuffer += toolFramingTail;
-            toolFramingTail = '';
-        }
-        else if (state === 'contentFraming' && contentFramingTail) {
-            // Cutoff inside a partial close marker — emit tail as content.
-            emitContent(events, contentFramingTail);
-            contentFramingTail = '';
-        }
-        if (state === 'toolFraming' && activeToolFrame) {
-            if (opts?.error) {
-                emitContent(events, toolCallBuffer);
-                toolCallBuffer = '';
-                activeToolFrame = null;
-            }
-            else {
-                flushToolBuffer(events, false);
-            }
-        }
-        else if (state === 'contentFraming') {
-            activeContentFrame = null;
-        }
-        activeThinkingFrame = null;
-        state = 'content';
-        if (!opts?.error) {
-            if (opts?.toolCalls) {
-                for (const call of opts.toolCalls) {
-                    emitFinalToolCall(events, call);
-                }
-            }
-        }
-        if (opts?.stats) {
-            events.push({
-                type: 'completionStats',
-                seq: nextSeq(),
-                stats: opts.stats
-            });
-        }
-        const raw = { fullText: rawText };
-        if (opts?.error) {
-            events.push({
-                type: 'completionDone',
-                seq: nextSeq(),
-                stopReason: 'error',
-                error: opts.error,
-                raw
-            });
-        }
-        else if (opts?.stopReason) {
-            events.push({
-                type: 'completionDone',
-                seq: nextSeq(),
-                stopReason: opts.stopReason,
-                raw
-            });
-        }
-        else {
-            events.push({ type: 'completionDone', seq: nextSeq(), raw });
-        }
-        return events;
-    }
-    function getAccumulated() {
-        return {
-            rawText,
-            contentText: contentParts.join(''),
-            thinkingText: thinkingParts.length > 0 ? thinkingParts.join('') : undefined
-        };
-    }
-    return { push, finish, getAccumulated };
-}

package/dist/server/utils/config-transform.d.ts

@@ -1,6 +0,0 @@
-import { type ModelTypeInput } from '../../schemas/index.js';
-export declare function getModelParallel(config: {
-    parallel?: number | undefined;
-}): number;
-export declare function transformConfigForReload(modelType: ModelTypeInput, config: unknown): unknown;
-//# sourceMappingURL=config-transform.d.ts.map

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

@@ -1,27 +0,0 @@
-import { normalizeModelType, ModelType } from '../../schemas/index.js';
-import { buildParakeetReloadConfig, buildWhisperReloadConfig } from '../../server/bare/plugins/asr-ggml/config.js';
-// The model's concurrent sequence slots. Missing / 0 / NaN all mean single-slot;
-// floor a fractional value so it can't over-admit.
-export function getModelParallel(config) {
-    const n = Math.floor(Number(config.parallel));
-    return Number.isFinite(n) && n >= 1 ? n : 1;
-}
-export function transformConfigForReload(modelType, config) {
-    const canonicalType = normalizeModelType(modelType);
-    switch (canonicalType) {
-        case ModelType.whispercppTranscription: {
-            return buildWhisperReloadConfig(config);
-        }
-        case ModelType.parakeetTranscription: {
-            return buildParakeetReloadConfig(config);
-        }
-        case ModelType.llamacppCompletion:
-        case ModelType.llamacppEmbedding:
-        case ModelType.nmtcppTranslation:
-        case ModelType.ttsGgml:
-            // 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,56 +0,0 @@
-import crypto from 'bare-crypto';
-import { Buffer } from 'bare-buffer';
-/**
- * Generate a short hash (16 characters) from any input string
- */
-export function generateShortHash(input) {
-    const hash = crypto.createHash('sha-256').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