@qvac/sdk 0.9.2 → 0.10.1

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,14 @@
+/**
+ * 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 (/gpt[_-]?oss/.test(tag))
+        return "harmony";
+    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,46 @@
+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";
+import { parseHarmonyFormat } from "./parsers/harmony.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];
+        case "harmony":
+            return [parseHarmonyFormat];
+        default:
+            // Harmony first: `to=functions.` is uniquely Harmony and can't
+            // false-match other dialects.
+            // Pythonic last: its bare `[name(...)]` form can match payloads that
+            // look like other dialects.
+            return [
+                parseHarmonyFormat,
+                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 };
+}

package/dist/server/utils/tools/parsers/harmony.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "../../../../schemas/index";
+import { type ParserResult } from "../shared";
+export declare function parseHarmonyFormat(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=harmony.d.ts.map

package/dist/server/utils/tools/parsers/harmony.js

@@ -0,0 +1,59 @@
+import { generateStableToolCallId, validateToolArguments, } from "../shared.js";
+const HARMONY_FRAME_RE = /to=functions\.([\w-]+)\s+<\|constrain\|>json<\|message\|>([\s\S]*?)(?=<\|call\|>|$)/g;
+export function parseHarmonyFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    if (!text.includes("to=functions.")) {
+        return { matched: false, toolCalls, errors };
+    }
+    HARMONY_FRAME_RE.lastIndex = 0;
+    let m;
+    while ((m = HARMONY_FRAME_RE.exec(text)) !== null) {
+        const name = m[1];
+        const payload = m[2]?.trim();
+        const raw = m[0];
+        if (!name || payload === undefined)
+            continue;
+        let parsedArgs;
+        try {
+            parsedArgs = JSON.parse(payload);
+        }
+        catch (error) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: `Failed to parse Harmony tool call JSON for ${name}: ${error instanceof Error ? error.message : String(error)}`,
+                raw,
+            });
+            continue;
+        }
+        if (typeof parsedArgs !== "object" ||
+            parsedArgs === null ||
+            Array.isArray(parsedArgs)) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: `Harmony tool call payload for ${name} is not a JSON object`,
+                raw,
+            });
+            continue;
+        }
+        const args = parsedArgs;
+        const validation = validateToolArguments(name, args, tools);
+        if (!validation.isValid && validation.error) {
+            errors.push({ ...validation.error, raw });
+            continue;
+        }
+        toolCalls.push({
+            id: generateStableToolCallId(name, args),
+            name,
+            arguments: args,
+            raw,
+        });
+    }
+    // Defer `matched` to extraction so partial Harmony shapes fall through
+    // to the next parser instead of short-circuiting the chain.
+    return {
+        matched: toolCalls.length > 0 || errors.length > 0,
+        toolCalls,
+        errors,
+    };
+}

package/dist/server/utils/tools/parsers/hermes.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "../../../../schemas/index";
+import { type ParserResult } from "../shared";
+export declare function parseHermesFormat(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=hermes.d.ts.map

package/dist/server/utils/tools/parsers/hermes.js

@@ -0,0 +1,100 @@
+import { generateStableToolCallId, isValidToolCall, validateToolArguments, } from "../shared.js";
+// Hermes-style: JSON payload wrapped in `<tool_call>...</tool_call>` tags
+export function parseHermesFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    if (!text.includes("<tool_call>")) {
+        return { matched: false, toolCalls, errors };
+    }
+    // Incomplete frame: open marker without close (cutoff/abort). Recover
+    // the inner buffer here — fallthrough to JSON parsers can't strip the
+    // `<tool_call>` prefix on its own.
+    if (!text.includes("</tool_call>")) {
+        return recoverIncompleteHermesFrame(text, tools);
+    }
+    const toolCallRegex = /<tool_call>\s*({[\s\S]*?})\s*<\/tool_call>/g;
+    const matches = Array.from(text.matchAll(toolCallRegex));
+    for (const match of matches) {
+        const callJson = match[1];
+        if (!callJson)
+            continue;
+        const trimmedJson = callJson.trim();
+        let callItem;
+        try {
+            callItem = JSON.parse(trimmedJson);
+        }
+        catch (error) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: `Failed to parse Hermes tool call: ${error instanceof Error ? error.message : String(error)}`,
+                raw: trimmedJson,
+            });
+            continue;
+        }
+        if (!isValidToolCall(callItem)) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: "Hermes tool call is missing name/arguments",
+                raw: trimmedJson,
+            });
+            continue;
+        }
+        const call = callItem;
+        const validation = validateToolArguments(call.name, call.arguments, tools);
+        if (!validation.isValid && validation.error) {
+            errors.push({
+                ...validation.error,
+                raw: trimmedJson,
+            });
+            continue;
+        }
+        toolCalls.push({
+            id: call.id || generateStableToolCallId(call.name, call.arguments),
+            name: call.name,
+            arguments: call.arguments,
+            raw: trimmedJson,
+        });
+    }
+    return { matched: true, toolCalls, errors };
+}
+// Strips a possible truncated close-tag tail (`</tool`, `</tool_c`)
+// before parsing. Bounded to buffers that actually contain the open marker.
+function recoverIncompleteHermesFrame(text, tools) {
+    const openIdx = text.indexOf("<tool_call>");
+    const inner = text.slice(openIdx + "<tool_call>".length).trim();
+    const partialCloseIdx = inner.search(/<\/tool/);
+    const candidate = partialCloseIdx === -1 ? inner : inner.slice(0, partialCloseIdx).trim();
+    if (candidate.length === 0) {
+        return { matched: false, toolCalls: [], errors: [] };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch {
+        return { matched: false, toolCalls: [], errors: [] };
+    }
+    if (!isValidToolCall(parsed)) {
+        return { matched: false, toolCalls: [], errors: [] };
+    }
+    const validation = validateToolArguments(parsed.name, parsed.arguments, tools);
+    if (!validation.isValid && validation.error) {
+        return {
+            matched: true,
+            toolCalls: [],
+            errors: [{ ...validation.error, raw: candidate }],
+        };
+    }
+    return {
+        matched: true,
+        toolCalls: [
+            {
+                id: parsed.id || generateStableToolCallId(parsed.name, parsed.arguments),
+                name: parsed.name,
+                arguments: parsed.arguments,
+                raw: candidate,
+            },
+        ],
+        errors: [],
+    };
+}

package/dist/server/utils/tools/parsers/json.d.ts

@@ -0,0 +1,6 @@
+import type { Tool } from "../../../../schemas/index";
+import { type ParserResult } from "../shared";
+export declare function parseGemmaFormat(text: string, tools: Tool[]): ParserResult;
+export declare function parseLlamacppFormat(text: string, tools: Tool[]): ParserResult;
+export declare function parseGenericFormat(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=json.d.ts.map

package/dist/server/utils/tools/parsers/json.js

@@ -0,0 +1,115 @@
+import { generateStableToolCallId, isValidToolCall, validateToolArguments, } from "../shared.js";
+export function parseGemmaFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { matched: false, toolCalls, errors };
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        !("tool_calls" in parsed) ||
+        !Array.isArray(parsed.tool_calls)) {
+        return { matched: false, toolCalls, errors };
+    }
+    for (const callItem of parsed.tool_calls) {
+        if (!isValidToolCall(callItem)) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: "Gemma tool_calls entry is missing name/arguments",
+                raw: JSON.stringify(callItem),
+            });
+            continue;
+        }
+        const call = callItem;
+        const validation = validateToolArguments(call.name, call.arguments, tools);
+        if (!validation.isValid && validation.error) {
+            errors.push({
+                ...validation.error,
+                raw: JSON.stringify(call),
+            });
+            continue;
+        }
+        toolCalls.push({
+            id: call.id || generateStableToolCallId(call.name, call.arguments),
+            name: call.name,
+            arguments: call.arguments,
+            raw: JSON.stringify(call),
+        });
+    }
+    return { matched: true, toolCalls, errors };
+}
+export function parseLlamacppFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    let parsedItem;
+    try {
+        parsedItem = JSON.parse(text);
+    }
+    catch {
+        return { matched: false, toolCalls, errors };
+    }
+    if (!isValidToolCall(parsedItem)) {
+        return { matched: false, toolCalls, errors };
+    }
+    const parsed = parsedItem;
+    const validation = validateToolArguments(parsed.name, parsed.arguments, tools);
+    if (!validation.isValid && validation.error) {
+        errors.push({
+            ...validation.error,
+            raw: text,
+        });
+    }
+    else {
+        toolCalls.push({
+            id: parsed.id || generateStableToolCallId(parsed.name, parsed.arguments),
+            name: parsed.name,
+            arguments: parsed.arguments,
+            raw: text,
+        });
+    }
+    return { matched: true, toolCalls, errors };
+}
+// Last-resort fallback: loose JSON `{"name":..., "arguments":...}` objects
+// anywhere in the text. Runs after dialect-specific parsers all miss.
+export function parseGenericFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    const jsonObjectRegex = /\{[\s\S]*?"name"[\s\S]*?"arguments"[\s\S]*?\}/g;
+    let match;
+    let matched = false;
+    while ((match = jsonObjectRegex.exec(text)) !== null) {
+        matched = true;
+        try {
+            const objItem = JSON.parse(match[0]);
+            if (isValidToolCall(objItem)) {
+                const obj = objItem;
+                const validation = validateToolArguments(obj.name, obj.arguments, tools);
+                if (!validation.isValid && validation.error) {
+                    errors.push({
+                        ...validation.error,
+                        raw: match[0],
+                    });
+                    continue;
+                }
+                toolCalls.push({
+                    id: obj.id || generateStableToolCallId(obj.name, obj.arguments),
+                    name: obj.name,
+                    arguments: obj.arguments,
+                    raw: match[0],
+                });
+            }
+        }
+        catch (error) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: `Failed to parse generic tool call: ${error instanceof Error ? error.message : String(error)}`,
+                raw: match[0],
+            });
+        }
+    }
+    return { matched, toolCalls, errors };
+}

package/dist/server/utils/tools/parsers/pythonic.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "../../../../schemas/index";
+import { type ParserResult } from "../shared";
+export declare function parsePythonicFormat(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=pythonic.d.ts.map