@qvac/sdk 0.9.2 → 0.10.0

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

@@ -0,0 +1,8 @@
+export interface CacheMessage {
+    role: string;
+    content: string;
+    attachments?: {
+        path: string;
+    }[] | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,4 +1,4 @@
-import type { DownloadMetricsHooks } 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?: DownloadMetricsHooks): Promise<string>;
+export declare function measureChecksum(filePath: string, hooks?: DownloadHooks): Promise<string>;
 //# sourceMappingURL=checksum.d.ts.map

package/dist/server/utils/checksum.js

@@ -26,6 +26,6 @@ export async function calculateFileChecksum(filePath) {
 export async function measureChecksum(filePath, hooks) {
     const start = nowMs();
     const checksum = await calculateFileChecksum(filePath);
-    hooks?.addChecksumValidationTimeMs(nowMs() - start);
+    hooks?.addChecksumValidationTimeMs?.(nowMs() - start);
     return checksum;
 }

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

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

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

@@ -0,0 +1,17 @@
+export function resolveClearStorageTarget(modelPath, modelsCacheDir) {
+    const normalizedCache = modelsCacheDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    const normalizedPath = modelPath.replace(/\\/g, "/");
+    if (!normalizedPath.startsWith(`${normalizedCache}/`)) {
+        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" };
+    }
+    return { path: modelPath, kind: "file" };
+}

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

@@ -0,0 +1,17 @@
+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[];
+    finish: (opts?: {
+        stats?: CompletionStats;
+        toolCalls?: ToolCall[];
+        error?: CompletionError;
+        stopReason?: StopReason;
+    }) => CompletionEvent[];
+    getAccumulated: () => {
+        rawText: string;
+        contentText: string;
+        thinkingText: string | undefined;
+    };
+};
+//# sourceMappingURL=completion-normalizer.d.ts.map

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

@@ -0,0 +1,301 @@
+import { parseToolCalls } from "./tools/index.js";
+const DIALECT_SPECS = {
+    hermes: {
+        frames: [{ open: "<tool_call>", close: "</tool_call>" }],
+    },
+    // No streaming framing — tool calls are only recovered at finalization.
+    json: {
+        frames: [],
+    },
+    pythonic: {
+        frames: [
+            { open: "<|tool_call_start|>", close: "<|tool_call_end|>" },
+            {
+                open: "<|start_header_id|>tool_call<|end_header_id|>",
+                close: "<|eot_id|>",
+            },
+        ],
+    },
+};
+const THINK_OPEN = "<think>";
+const THINK_CLOSE = "</think>";
+export function createCompletionNormalizer(config) {
+    let seq = 0;
+    let state = "content";
+    let rawText = "";
+    const contentParts = [];
+    const thinkingParts = [];
+    // Frame buffer keeps the open + close markers in place so parseToolCalls
+    // can match its own dialect markers.
+    let toolCallBuffer = "";
+    let activeFrame = 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 toolTail = "";
+    let thinkingTail = "";
+    const streamedToolCallKeys = new Set();
+    const toolsEnabled = config.tools.length > 0 && config.capabilities.toolCalling !== "none";
+    const useFramedParsing = toolsEnabled && config.capabilities.toolCalling === "textParse";
+    const useThinkingParsing = config.captureThinking && config.capabilities.thinkingFraming === "thinkTags";
+    const dialect = config.toolDialect ?? "hermes";
+    const dialectSpec = DIALECT_SPECS[dialect];
+    const frameSpecs = useFramedParsing ? dialectSpec.frames : [];
+    const contentMarkers = [];
+    if (useThinkingParsing)
+        contentMarkers.push(THINK_OPEN);
+    for (const f of frameSpecs)
+        contentMarkers.push(f.open);
+    function nextSeq() {
+        return seq++;
+    }
+    function emitContent(events, text) {
+        if (!text)
+            return;
+        contentParts.push(text);
+        events.push({ type: "contentDelta", seq: nextSeq(), text });
+    }
+    function emitThinking(events, text) {
+        if (!text)
+            return;
+        thinkingParts.push(text);
+        if (config.captureThinking) {
+            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 = activeFrame;
+        toolCallBuffer = "";
+        activeFrame = null;
+        toolTail = "";
+        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 processSegment(events, text) {
+        let buf = (state === "content"
+            ? contentTail
+            : state === "thinking"
+                ? thinkingTail
+                : toolTail) + text;
+        contentTail = "";
+        thinkingTail = "";
+        toolTail = "";
+        while (buf.length > 0) {
+            if (state === "toolBuffering") {
+                if (!activeFrame) {
+                    state = "content";
+                    continue;
+                }
+                const hit = buf.indexOf(activeFrame.close);
+                if (hit >= 0) {
+                    toolCallBuffer += buf.slice(0, hit + activeFrame.close.length);
+                    buf = buf.slice(hit + activeFrame.close.length);
+                    state = "content";
+                    flushToolBuffer(events, true);
+                    continue;
+                }
+                const tailLen = trailingPartialMarkerLen(buf, [activeFrame.close]);
+                const safeLen = buf.length - tailLen;
+                toolCallBuffer += buf.slice(0, safeLen);
+                toolTail = buf.slice(safeLen);
+                buf = "";
+                continue;
+            }
+            if (state === "thinking") {
+                const closeIdx = buf.indexOf(THINK_CLOSE);
+                if (closeIdx >= 0) {
+                    emitThinking(events, buf.slice(0, closeIdx));
+                    buf = buf.slice(closeIdx + THINK_CLOSE.length);
+                    state = "content";
+                    continue;
+                }
+                const tailLen = trailingPartialMarkerLen(buf, [THINK_CLOSE]);
+                const safeLen = buf.length - tailLen;
+                emitThinking(events, buf.slice(0, safeLen));
+                thinkingTail = buf.slice(safeLen);
+                buf = "";
+                continue;
+            }
+            const hit = findEarliestMarker(buf, contentMarkers);
+            if (hit) {
+                emitContent(events, buf.slice(0, hit.idx));
+                if (hit.marker === THINK_OPEN) {
+                    buf = buf.slice(hit.idx + hit.marker.length);
+                    state = "thinking";
+                    continue;
+                }
+                const spec = frameSpecs.find((f) => f.open === hit.marker);
+                toolCallBuffer = hit.marker;
+                activeFrame = spec;
+                buf = buf.slice(hit.idx + hit.marker.length);
+                state = "toolBuffering";
+                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 === "thinking" && thinkingTail) {
+            emitThinking(events, thinkingTail);
+            thinkingTail = "";
+        }
+        else if (state === "toolBuffering" && toolTail) {
+            toolCallBuffer += toolTail;
+            toolTail = "";
+        }
+        if (state === "toolBuffering" && activeFrame) {
+            if (opts?.error) {
+                emitContent(events, toolCallBuffer);
+                toolCallBuffer = "";
+                activeFrame = null;
+            }
+            else {
+                flushToolBuffer(events, false);
+            }
+        }
+        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/expand-gguf-shards.d.ts

@@ -0,0 +1,3 @@
+/** Expand a sharded GGUF path into `.tensors.txt` plus all shards. */
+export declare function expandGGUFIntoShards(modelPath: string): string[];
+//# sourceMappingURL=expand-gguf-shards.d.ts.map

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

@@ -0,0 +1,22 @@
+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 filename = lastSep >= 0 ? modelPath.slice(lastSep + 1) : modelPath;
+    const match = filename.match(SHARD_PATTERN);
+    if (!match || !match[1] || !match[3])
+        return [modelPath];
+    const baseFilename = match[1];
+    const totalDigits = match[3];
+    const totalShards = Number.parseInt(totalDigits, 10);
+    if (totalShards <= 0)
+        return [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`));
+    }
+    return shards;
+}

package/dist/server/utils/formatting.js

@@ -13,7 +13,7 @@ function isModelDescriptor(value) {
     return (typeof value === "object" &&
         value !== null &&
         "src" in value &&
-        typeof value.src === "string");
+        typeof (value).src === "string");
 }
 function normalizeValue(value) {
     if (isModelDescriptor(value)) {

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

@@ -1,10 +1,12 @@
 export * from "./archive";
-export * from "./cache";
+export * from "./cache/types";
+export * from "./cache/auto-history";
+export * from "./cache/paths";
 export * from "./checksum";
 export * from "./config-transform";
+export * from "./expand-gguf-shards";
 export * from "./formatting";
 export * from "./gguf-tensor-extractor";
-export * from "./model-path";
 export * from "./path-security";
 export * from "./shard-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,9 +1,11 @@
 export * from "./archive.js";
-export * from "./cache.js";
+export * from "./cache/types.js";
+export * from "./cache/auto-history.js";
+export * from "./cache/paths.js";
 export * from "./checksum.js";
 export * from "./config-transform.js";
+export * from "./expand-gguf-shards.js";
 export * from "./formatting.js";
 export * from "./gguf-tensor-extractor.js";
-export * from "./model-path.js";
 export * from "./path-security.js";
 export * from "./shard-utils.js";

package/dist/server/utils/qvac-paths.d.ts

@@ -0,0 +1,2 @@
+export declare function getQvacPath(...subPaths: string[]): string;
+//# sourceMappingURL=qvac-paths.d.ts.map

package/dist/server/utils/qvac-paths.js

@@ -0,0 +1,5 @@
+import path from "bare-path";
+import { getEnv } from "../env.js";
+export function getQvacPath(...subPaths) {
+    return path.join(getEnv().HOME_DIR, ".qvac", ...subPaths);
+}

package/dist/server/utils/response-format.d.ts

@@ -0,0 +1,3 @@
+import type { ResponseFormat } from "../../schemas/index";
+export declare function getResponseFormatJsonSchema(responseFormat: ResponseFormat): string | undefined;
+//# sourceMappingURL=response-format.d.ts.map

package/dist/server/utils/response-format.js

@@ -0,0 +1,20 @@
+// Translates the request-level `responseFormat` into the JSON Schema string
+// that the llama.cpp addon's per-request `generationParams.json_schema`
+// expects. Returns `undefined` for `{ type: "text" }` (no constraint).
+//
+// The addon converts the schema to GBNF natively via
+// `json_schema_to_grammar()` and applies it for the duration of the request
+// only, restoring the prior sampling block afterwards — so this surface is
+// safe to use under concurrent completions on the same model. (Tool calling
+// still goes through `setupToolGrammar` / `modelConfig.grammar`; see the
+// mutual-exclusion check in `completionClientParamsSchema`.)
+export function getResponseFormatJsonSchema(responseFormat) {
+    switch (responseFormat.type) {
+        case "text":
+            return undefined;
+        case "json_object":
+            return JSON.stringify({ type: "object" });
+        case "json_schema":
+            return JSON.stringify(responseFormat.json_schema.schema);
+    }
+}

package/dist/server/utils/tool-integration.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, ToolCallEvent } from "../../schemas/index";
+import type { Tool, ToolDialect } from "../../schemas/index";
 interface HistoryMessage {
     role: string;
     content: string;
@@ -6,8 +6,19 @@ interface HistoryMessage {
         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[];
+/**
+ * Static tools mode: prepend tools right after the system message (or at the
+ * very start when no system message is present). The tool block stays in the
+ * kv-cache for the whole chat session.
+ */
+export declare function prependToolsToHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
+/**
+ * Dynamic tools mode: append tools after the last history message. The
+ * addon's compact-tools mode anchors the block after the last user message
+ * and trims it from the kv-cache once the tool-call chain resolves, so a
+ * subsequent turn can ship a different tool set without poisoning the cache.
+ */
+export declare function appendToolsToHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
+export declare function detectToolDialect(modelId: string): ToolDialect;
 export {};
 //# sourceMappingURL=tool-integration.d.ts.map

package/dist/server/utils/tool-integration.js

@@ -1,5 +1,11 @@
-import { parseToolCalls, convertToolsToGrammar, } from "./tool-parser.js";
-export function insertToolsIntoHistory(history, tools) {
+import { detectToolDialectFromName } from "./tools/index.js";
+import { getModelInfo } from "../bare/registry/model-registry.js";
+/**
+ * Static tools mode: prepend tools right after the system message (or at the
+ * very start when no system message is present). The tool block stays in the
+ * kv-cache for the whole chat session.
+ */
+export function prependToolsToHistory(history, tools) {
     const systemMsgIndex = history.findIndex((msg) => msg.role === "system");
     if (systemMsgIndex >= 0) {
         return [
@@ -10,44 +16,18 @@ export function insertToolsIntoHistory(history, tools) {
     }
     return [...tools, ...history];
 }
-export function setupToolGrammar(modelConfig, tools) {
-    const grammar = convertToolsToGrammar(tools);
-    modelConfig["grammar"] = grammar;
+/**
+ * Dynamic tools mode: append tools after the last history message. The
+ * addon's compact-tools mode anchors the block after the last user message
+ * and trims it from the kv-cache once the tool-call chain resolves, so a
+ * subsequent turn can ship a different tool set without poisoning the cache.
+ */
+export function appendToolsToHistory(history, tools) {
+    return [...history, ...tools];
 }
-function isInsideThinkBlock(text) {
-    const lastOpen = text.lastIndexOf("<think>");
-    if (lastOpen === -1)
-        return false;
-    const lastClose = text.lastIndexOf("</think>");
-    return lastClose < lastOpen;
-}
-export function checkForToolEvents(accumulatedText, currentToken, tools, emittedToolCallPositions) {
-    const events = [];
-    if (isInsideThinkBlock(accumulatedText)) {
-        return events;
-    }
-    if (currentToken.includes("</tool_call>") || currentToken.includes("}")) {
-        const { toolCalls, errors } = parseToolCalls(accumulatedText, tools);
-        for (const call of toolCalls) {
-            const callPosition = accumulatedText.indexOf(call.raw || "");
-            if (callPosition >= 0 && !emittedToolCallPositions.has(callPosition)) {
-                emittedToolCallPositions.add(callPosition);
-                events.push({
-                    type: "toolCall",
-                    call,
-                });
-            }
-        }
-        for (const error of errors) {
-            const errorPosition = accumulatedText.indexOf(error.raw || "");
-            if (errorPosition >= 0 && !emittedToolCallPositions.has(errorPosition)) {
-                emittedToolCallPositions.add(errorPosition);
-                events.push({
-                    type: "toolCallError",
-                    error,
-                });
-            }
-        }
-    }
-    return events;
+export function detectToolDialect(modelId) {
+    const info = getModelInfo(modelId);
+    if (!info)
+        return "hermes";
+    return detectToolDialectFromName(info.name, info.path);
 }

package/dist/server/utils/tools/dialect.d.ts

@@ -0,0 +1,8 @@
+import type { ToolDialect } from "../../../schemas/index";
+/**
+ * Detects the tool-call dialect from a model's registry name and file path.
+ * Defaults to "hermes" (its parser chain also covers unknown JSON-payload
+ * models). Bypass with `completion({ toolDialect })`.
+ */
+export declare function detectToolDialectFromName(name: string | undefined, path: string): ToolDialect;
+//# sourceMappingURL=dialect.d.ts.map

package/dist/server/utils/tools/dialect.js

@@ -0,0 +1,12 @@
+/**
+ * Detects the tool-call dialect from a model's registry name and file path.
+ * Defaults to "hermes" (its parser chain also covers unknown JSON-payload
+ * models). Bypass with `completion({ toolDialect })`.
+ */
+export function detectToolDialectFromName(name, path) {
+    const basename = path.toLowerCase().split(/[/\\]/).pop() ?? "";
+    const tag = `${(name ?? "").toLowerCase()}|${basename}`;
+    if (/lfm[_-]?\d/.test(tag))
+        return "pythonic";
+    return "hermes";
+}

package/dist/server/utils/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { detectToolDialectFromName } from "./dialect";
+export { parseToolCalls } from "./parser";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/utils/tools/index.js

@@ -0,0 +1,2 @@
+export { detectToolDialectFromName } from "./dialect.js";
+export { parseToolCalls } from "./parser.js";

package/dist/server/utils/tools/parser.d.ts

@@ -0,0 +1,6 @@
+import type { Tool, ToolCall, ToolCallError, ToolDialect } from "../../../schemas/index";
+export declare function parseToolCalls(text: string, tools: Tool[], dialect?: ToolDialect): {
+    toolCalls: ToolCall[];
+    errors: ToolCallError[];
+};
+//# sourceMappingURL=parser.d.ts.map

package/dist/server/utils/tools/parser.js

@@ -0,0 +1,40 @@
+import { stripThinkingBlocks, } from "./shared.js";
+import { parseGemmaFormat, parseGenericFormat, parseLlamacppFormat, } from "./parsers/json.js";
+import { parseHermesFormat } from "./parsers/hermes.js";
+import { parsePythonicFormat } from "./parsers/pythonic.js";
+function pickFormatParsers(dialect) {
+    switch (dialect) {
+        case "pythonic":
+            return [parsePythonicFormat];
+        case "hermes":
+            // Hermes first so frame errors surface; JSON fallbacks then cover
+            // unknown JSON-payload models.
+            return [parseHermesFormat, parseGemmaFormat, parseLlamacppFormat];
+        case "json":
+            return [parseGemmaFormat, parseLlamacppFormat];
+        default:
+            // Pythonic last: its bare `[name(...)]` form can match payloads that
+            // look like other dialects.
+            return [
+                parseHermesFormat,
+                parseGemmaFormat,
+                parseLlamacppFormat,
+                parsePythonicFormat,
+            ];
+    }
+}
+export function parseToolCalls(text, tools, dialect) {
+    if (!tools || tools.length === 0) {
+        return { toolCalls: [], errors: [] };
+    }
+    const cleaned = stripThinkingBlocks(text);
+    const formatParsers = pickFormatParsers(dialect);
+    for (const parser of formatParsers) {
+        const result = parser(cleaned, tools);
+        if (result.matched) {
+            return { toolCalls: result.toolCalls, errors: result.errors };
+        }
+    }
+    const generic = parseGenericFormat(cleaned, tools);
+    return { toolCalls: generic.toolCalls, errors: generic.errors };
+}