@qvac/sdk 0.14.0 → 0.15.0

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

@@ -1,66 +1,62 @@
-import { parseToolCalls } from "./tools/index.js";
+import { parseToolCalls } from './tools/index.js';
 const DIALECT_SPECS = {
     hermes: {
-        toolFrames: [{ open: "<tool_call>", close: "</tool_call>" }],
+        toolFrames: [{ open: '<tool_call>', close: '</tool_call>' }]
     },
     // No streaming framing — tool calls are only recovered at finalization.
     json: {
-        toolFrames: [],
+        toolFrames: []
     },
     pythonic: {
         toolFrames: [
-            { open: "<|tool_call_start|>", close: "<|tool_call_end|>" },
+            { open: '<|tool_call_start|>', close: '<|tool_call_end|>' },
             {
-                open: "<|start_header_id|>tool_call<|end_header_id|>",
-                close: "<|eot_id|>",
-            },
-        ],
+                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|>" },
-        ],
+        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|>" },
+            { 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|>",
+            '<|message|>',
+            '<|end|>',
+            '<|start|>assistant',
+            '<|start|>system',
+            '<|start|>user',
+            '<|return|>'
         ],
-        contentDropTokens: ["<|channel|>"],
+        contentDropTokens: ['<|channel|>']
     },
     qwen35: {
         // Same <tool_call>…</tool_call> framing as hermes; inner content is XML.
-        toolFrames: [{ open: "<tool_call>", close: "</tool_call>" }],
+        toolFrames: [{ open: '<tool_call>', close: '</tool_call>' }]
     },
     gemma4: {
-        toolFrames: [{ open: "<|tool_call>", close: "<tool_call|>" }],
-        thinkingFrames: [{ open: "<|channel>thought", close: "<channel|>" }],
-    },
+        toolFrames: [{ open: '<|tool_call>', close: '<tool_call|>' }],
+        thinkingFrames: [{ open: '<|channel>thought', close: '<channel|>' }]
+    }
 };
 // 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>" };
+const BUILTIN_THINKING = { open: '<think>', close: '</think>' };
 export function createCompletionNormalizer(config) {
     let seq = 0;
-    let state = "content";
-    let rawText = "";
+    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 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
@@ -70,25 +66,22 @@ export function createCompletionNormalizer(config) {
     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 = "";
+    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";
+    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 useBuiltinThinkTags = config.captureThinking && config.capabilities.thinkingFraming === 'thinkTags';
+    const dialect = config.toolDialect ?? 'hermes';
     const dialectSpec = DIALECT_SPECS[dialect];
-    const toolFrames = useToolFraming
-        ? dialectSpec.toolFrames
-        : [];
+    const toolFrames = useToolFraming ? dialectSpec.toolFrames : [];
     const thinkingFrames = [
         ...(useBuiltinThinkTags ? [BUILTIN_THINKING] : []),
-        ...(dialectSpec.thinkingFrames ?? []),
+        ...(dialectSpec.thinkingFrames ?? [])
     ];
     const contentFrames = dialectSpec.contentFrames ?? [];
     const dropTokens = dialectSpec.dropTokens ?? [];
@@ -104,9 +97,9 @@ export function createCompletionNormalizer(config) {
             contentMarkers.push(f.open);
         }
     }
-    registerFrames(toolFrames, "tool");
-    registerFrames(thinkingFrames, "thinking");
-    registerFrames(contentFrames, "content");
+    registerFrames(toolFrames, 'tool');
+    registerFrames(thinkingFrames, 'thinking');
+    registerFrames(contentFrames, 'content');
     for (const t of dropTokens) {
         if (markerToEntry.has(t) || dropTokenSet.has(t))
             continue;
@@ -119,12 +112,12 @@ export function createCompletionNormalizer(config) {
     function emitContent(events, text) {
         let normalized = text;
         for (const token of contentDropTokens) {
-            normalized = normalized.split(token).join("");
+            normalized = normalized.split(token).join('');
         }
         if (!normalized)
             return;
         contentParts.push(normalized);
-        events.push({ type: "contentDelta", seq: nextSeq(), text: 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
@@ -134,7 +127,7 @@ export function createCompletionNormalizer(config) {
             return;
         if (config.captureThinking) {
             thinkingParts.push(text);
-            events.push({ type: "thinkingDelta", seq: nextSeq(), text });
+            events.push({ type: 'thinkingDelta', seq: nextSeq(), text });
         }
     }
     function getToolCallKey(call) {
@@ -142,12 +135,12 @@ export function createCompletionNormalizer(config) {
     }
     function emitStreamedToolCall(events, call) {
         streamedToolCallKeys.add(getToolCallKey(call));
-        events.push({ type: "toolCall", seq: nextSeq(), 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 });
+        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) {
@@ -177,9 +170,9 @@ export function createCompletionNormalizer(config) {
     function flushToolBuffer(events, closed) {
         const raw = toolCallBuffer;
         const frame = activeToolFrame;
-        toolCallBuffer = "";
+        toolCallBuffer = '';
         activeToolFrame = null;
-        toolFramingTail = "";
+        toolFramingTail = '';
         if (!frame)
             return;
         // Empty-payload guard. Strip frame markers and check the inner is
@@ -193,9 +186,9 @@ export function createCompletionNormalizer(config) {
         }
         if (inner.trim().length === 0) {
             events.push({
-                type: "toolError",
+                type: 'toolError',
                 seq: nextSeq(),
-                error: { code: "PARSE_ERROR", message: "Empty tool_call frame" },
+                error: { code: 'PARSE_ERROR', message: 'Empty tool_call frame' }
             });
             return;
         }
@@ -205,20 +198,20 @@ export function createCompletionNormalizer(config) {
         if (toolCalls.length === 0) {
             if (errors.length > 0) {
                 for (const error of errors) {
-                    events.push({ type: "toolError", seq: nextSeq(), error });
+                    events.push({ type: 'toolError', seq: nextSeq(), error });
                 }
             }
             else {
                 events.push({
-                    type: "toolError",
+                    type: 'toolError',
                     seq: nextSeq(),
                     error: {
-                        code: "PARSE_ERROR",
+                        code: 'PARSE_ERROR',
                         message: closed
-                            ? "Failed to parse tool call from framed region"
-                            : "Incomplete tool call frame at stream end",
-                        raw,
-                    },
+                            ? 'Failed to parse tool call from framed region'
+                            : 'Incomplete tool call frame at stream end',
+                        raw
+                    }
                 });
             }
             emitContent(events, raw);
@@ -226,33 +219,33 @@ export function createCompletionNormalizer(config) {
     }
     function getStateTail() {
         switch (state) {
-            case "content":
+            case 'content':
                 return contentTail;
-            case "thinkingFraming":
+            case 'thinkingFraming':
                 return thinkingFramingTail;
-            case "toolFraming":
+            case 'toolFraming':
                 return toolFramingTail;
-            case "contentFraming":
+            case 'contentFraming':
                 return contentFramingTail;
         }
     }
     function processSegment(events, text) {
         let buf = getStateTail() + text;
-        contentTail = "";
-        thinkingFramingTail = "";
-        toolFramingTail = "";
-        contentFramingTail = "";
+        contentTail = '';
+        thinkingFramingTail = '';
+        toolFramingTail = '';
+        contentFramingTail = '';
         while (buf.length > 0) {
-            if (state === "toolFraming") {
+            if (state === 'toolFraming') {
                 if (!activeToolFrame) {
-                    state = "content";
+                    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";
+                    state = 'content';
                     flushToolBuffer(events, true);
                     continue;
                 }
@@ -260,12 +253,12 @@ export function createCompletionNormalizer(config) {
                 const safeLen = buf.length - tailLen;
                 toolCallBuffer += buf.slice(0, safeLen);
                 toolFramingTail = buf.slice(safeLen);
-                buf = "";
+                buf = '';
                 continue;
             }
-            if (state === "thinkingFraming") {
+            if (state === 'thinkingFraming') {
                 if (!activeThinkingFrame) {
-                    state = "content";
+                    state = 'content';
                     continue;
                 }
                 const closeMarker = activeThinkingFrame.close;
@@ -274,19 +267,19 @@ export function createCompletionNormalizer(config) {
                     emitThinking(events, buf.slice(0, closeIdx));
                     buf = buf.slice(closeIdx + closeMarker.length);
                     activeThinkingFrame = null;
-                    state = "content";
+                    state = 'content';
                     continue;
                 }
                 const tailLen = trailingPartialMarkerLen(buf, [closeMarker]);
                 const safeLen = buf.length - tailLen;
                 emitThinking(events, buf.slice(0, safeLen));
                 thinkingFramingTail = buf.slice(safeLen);
-                buf = "";
+                buf = '';
                 continue;
             }
-            if (state === "contentFraming") {
+            if (state === 'contentFraming') {
                 if (!activeContentFrame) {
-                    state = "content";
+                    state = 'content';
                     continue;
                 }
                 const closeMarker = activeContentFrame.close;
@@ -294,16 +287,16 @@ export function createCompletionNormalizer(config) {
                 if (closeIdx >= 0) {
                     emitContent(events, buf.slice(0, closeIdx));
                     activeContentFrame = null;
-                    contentFramingTail = "";
+                    contentFramingTail = '';
                     buf = buf.slice(closeIdx + closeMarker.length);
-                    state = "content";
+                    state = 'content';
                     continue;
                 }
                 const tailLen = trailingPartialMarkerLen(buf, [closeMarker]);
                 const safeLen = buf.length - tailLen;
                 emitContent(events, buf.slice(0, safeLen));
                 contentFramingTail = buf.slice(safeLen);
-                buf = "";
+                buf = '';
                 continue;
             }
             const hit = findEarliestMarker(buf, contentMarkers);
@@ -315,18 +308,18 @@ export function createCompletionNormalizer(config) {
                     continue;
                 }
                 const entry = markerToEntry.get(hit.marker);
-                if (entry.kind === "tool") {
+                if (entry.kind === 'tool') {
                     toolCallBuffer = hit.marker;
                     activeToolFrame = entry.spec;
-                    state = "toolFraming";
+                    state = 'toolFraming';
                 }
-                else if (entry.kind === "thinking") {
+                else if (entry.kind === 'thinking') {
                     activeThinkingFrame = entry.spec;
-                    state = "thinkingFraming";
+                    state = 'thinkingFraming';
                 }
                 else {
                     activeContentFrame = entry.spec;
-                    state = "contentFraming";
+                    state = 'contentFraming';
                 }
                 continue;
             }
@@ -334,14 +327,14 @@ export function createCompletionNormalizer(config) {
             const safeLen = buf.length - tailLen;
             emitContent(events, buf.slice(0, safeLen));
             contentTail = buf.slice(safeLen);
-            buf = "";
+            buf = '';
         }
     }
     function push(token) {
         const events = [];
         rawText += token;
         if (config.emitRawDeltas) {
-            events.push({ type: "rawDelta", seq: nextSeq(), text: token });
+            events.push({ type: 'rawDelta', seq: nextSeq(), text: token });
         }
         processSegment(events, token);
         return events;
@@ -350,38 +343,38 @@ export function createCompletionNormalizer(config) {
         const events = [];
         // Drain pending tail bytes so we don't lose trailing chars when the
         // stream ends mid-marker.
-        if (state === "content" && contentTail) {
+        if (state === 'content' && contentTail) {
             emitContent(events, contentTail);
-            contentTail = "";
+            contentTail = '';
         }
-        else if (state === "thinkingFraming" && thinkingFramingTail) {
+        else if (state === 'thinkingFraming' && thinkingFramingTail) {
             emitThinking(events, thinkingFramingTail);
-            thinkingFramingTail = "";
+            thinkingFramingTail = '';
         }
-        else if (state === "toolFraming" && toolFramingTail) {
+        else if (state === 'toolFraming' && toolFramingTail) {
             toolCallBuffer += toolFramingTail;
-            toolFramingTail = "";
+            toolFramingTail = '';
         }
-        else if (state === "contentFraming" && contentFramingTail) {
+        else if (state === 'contentFraming' && contentFramingTail) {
             // Cutoff inside a partial close marker — emit tail as content.
             emitContent(events, contentFramingTail);
-            contentFramingTail = "";
+            contentFramingTail = '';
         }
-        if (state === "toolFraming" && activeToolFrame) {
+        if (state === 'toolFraming' && activeToolFrame) {
             if (opts?.error) {
                 emitContent(events, toolCallBuffer);
-                toolCallBuffer = "";
+                toolCallBuffer = '';
                 activeToolFrame = null;
             }
             else {
                 flushToolBuffer(events, false);
             }
         }
-        else if (state === "contentFraming") {
+        else if (state === 'contentFraming') {
             activeContentFrame = null;
         }
         activeThinkingFrame = null;
-        state = "content";
+        state = 'content';
         if (!opts?.error) {
             if (opts?.toolCalls) {
                 for (const call of opts.toolCalls) {
@@ -391,39 +384,39 @@ export function createCompletionNormalizer(config) {
         }
         if (opts?.stats) {
             events.push({
-                type: "completionStats",
+                type: 'completionStats',
                 seq: nextSeq(),
-                stats: opts.stats,
+                stats: opts.stats
             });
         }
         const raw = { fullText: rawText };
         if (opts?.error) {
             events.push({
-                type: "completionDone",
+                type: 'completionDone',
                 seq: nextSeq(),
-                stopReason: "error",
+                stopReason: 'error',
                 error: opts.error,
-                raw,
+                raw
             });
         }
         else if (opts?.stopReason) {
             events.push({
-                type: "completionDone",
+                type: 'completionDone',
                 seq: nextSeq(),
                 stopReason: opts.stopReason,
-                raw,
+                raw
             });
         }
         else {
-            events.push({ type: "completionDone", seq: nextSeq(), raw });
+            events.push({ type: 'completionDone', seq: nextSeq(), raw });
         }
         return events;
     }
     function getAccumulated() {
         return {
             rawText,
-            contentText: contentParts.join(""),
-            thinkingText: thinkingParts.length > 0 ? thinkingParts.join("") : undefined,
+            contentText: contentParts.join(''),
+            thinkingText: thinkingParts.length > 0 ? thinkingParts.join('') : undefined
         };
     }
     return { push, finish, getAccumulated };

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

@@ -1,3 +1,3 @@
-import { type ModelTypeInput } from "../../schemas/index";
+import { type ModelTypeInput } from '../../schemas/index';
 export declare function transformConfigForReload(modelType: ModelTypeInput, config: unknown): unknown;
 //# sourceMappingURL=config-transform.d.ts.map

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

@@ -1,4 +1,4 @@
-import { normalizeModelType, ModelType, } from "../../schemas/index.js";
+import { normalizeModelType, ModelType } from '../../schemas/index.js';
 export function transformConfigForReload(modelType, config) {
     const canonicalType = normalizeModelType(modelType);
     switch (canonicalType) {
@@ -8,7 +8,7 @@ export function transformConfigForReload(modelType, config) {
             const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
             return {
                 whisperConfig: whisperParams,
-                ...(miscConfig && { miscConfig }),
+                ...(miscConfig && { miscConfig })
             };
         }
         case ModelType.llamacppCompletion:

package/dist/server/utils/expand-gguf-shards.js

@@ -1,9 +1,9 @@
 const SHARD_PATTERN = /^(.+)-(\d{5})-of-(\d{5})\.gguf$/;
 /** Expand a sharded GGUF path into `.tensors.txt` plus all shards. */
 export function expandGGUFIntoShards(modelPath) {
-    const lastSep = Math.max(modelPath.lastIndexOf("/"), modelPath.lastIndexOf("\\"));
-    const dir = lastSep >= 0 ? modelPath.slice(0, lastSep) : "";
-    const sep = lastSep >= 0 ? modelPath.charAt(lastSep) : "/";
+    const lastSep = Math.max(modelPath.lastIndexOf('/'), modelPath.lastIndexOf('\\'));
+    const dir = lastSep >= 0 ? modelPath.slice(0, lastSep) : '';
+    const sep = lastSep >= 0 ? modelPath.charAt(lastSep) : '/';
     const filename = lastSep >= 0 ? modelPath.slice(lastSep + 1) : modelPath;
     const match = filename.match(SHARD_PATTERN);
     if (!match || !match[1] || !match[3])
@@ -16,7 +16,7 @@ export function expandGGUFIntoShards(modelPath) {
     const join = (name) => (dir ? `${dir}${sep}${name}` : name);
     const shards = [join(`${baseFilename}.tensors.txt`)];
     for (let i = 1; i <= totalShards; i++) {
-        shards.push(join(`${baseFilename}-${String(i).padStart(5, "0")}-of-${totalDigits}.gguf`));
+        shards.push(join(`${baseFilename}-${String(i).padStart(5, '0')}-of-${totalDigits}.gguf`));
     }
     return shards;
 }

package/dist/server/utils/formatting.js

@@ -1,20 +1,14 @@
-import crypto from "bare-crypto";
-import { Buffer } from "bare-buffer";
+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");
+    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");
+    return (typeof value === 'object' && value !== null && 'src' in value && typeof value.src === 'string');
 }
 function normalizeValue(value) {
     if (isModelDescriptor(value)) {
@@ -23,7 +17,7 @@ function normalizeValue(value) {
     if (Array.isArray(value)) {
         return value.map(normalizeValue);
     }
-    if (typeof value === "object" && value !== null) {
+    if (typeof value === 'object' && value !== null) {
         return normalizeConfig(value);
     }
     return value;
@@ -42,7 +36,7 @@ function normalizeConfig(config) {
  */
 export function canonicalConfigString(config) {
     if (!config)
-        return "{}";
+        return '{}';
     return JSON.stringify(normalizeConfig(config));
 }
 /**