@qvac/sdk 0.18.2 → 0.19.1

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

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

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

@@ -1,267 +0,0 @@
-import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-// Pythonic `[name(k=v), ...]` arrays. LFM 2.x is auto-routed; Llama-style
-// tokens are kept for callers that opt in via `completion({ toolDialect:
-// "pythonic" })` for a model known to emit Pythonic. Pure string parsing —
-// no eval/vm/Function (untrusted model output).
-const PYTHONIC_LFM_OPEN = '<|tool_call_start|>';
-const PYTHONIC_LFM_CLOSE = '<|tool_call_end|>';
-const PYTHONIC_LLAMA_OPEN = '<|start_header_id|>tool_call<|end_header_id|>';
-const PYTHONIC_LLAMA_CLOSE = '<|eot_id|>';
-function locatePythonicCallList(text) {
-    const lfmStart = text.indexOf(PYTHONIC_LFM_OPEN);
-    if (lfmStart !== -1) {
-        const after = text.slice(lfmStart + PYTHONIC_LFM_OPEN.length);
-        const end = after.indexOf(PYTHONIC_LFM_CLOSE);
-        return end === -1 ? after : after.slice(0, end);
-    }
-    const llamaStart = text.indexOf(PYTHONIC_LLAMA_OPEN);
-    if (llamaStart !== -1) {
-        const after = text.slice(llamaStart + PYTHONIC_LLAMA_OPEN.length);
-        const end = after.indexOf(PYTHONIC_LLAMA_CLOSE);
-        return end === -1 ? after : after.slice(0, end);
-    }
-    // Identifier+`(` requirement rejects JSON arrays and plain bracketed lists.
-    const bareMatch = /\[\s*[A-Za-z_]\w*\s*\(/.exec(text);
-    if (bareMatch)
-        return text.slice(bareMatch.index);
-    return null;
-}
-function pyPeek(s, offset = 0) {
-    return s.text[s.pos + offset] ?? '';
-}
-function pyConsume(s) {
-    const c = s.text[s.pos] ?? '';
-    s.pos++;
-    return c;
-}
-function pySkipWs(s) {
-    while (/\s/.test(pyPeek(s)))
-        s.pos++;
-}
-function pyParseString(s) {
-    const quote = pyConsume(s);
-    let out = '';
-    while (s.pos < s.text.length && pyPeek(s) !== quote) {
-        if (pyPeek(s) === '\\') {
-            s.pos++;
-            const esc = pyConsume(s);
-            switch (esc) {
-                case 'n':
-                    out += '\n';
-                    break;
-                case 't':
-                    out += '\t';
-                    break;
-                case 'r':
-                    out += '\r';
-                    break;
-                case '\\':
-                    out += '\\';
-                    break;
-                case "'":
-                    out += "'";
-                    break;
-                case '"':
-                    out += '"';
-                    break;
-                case '0':
-                    out += '\0';
-                    break;
-                default:
-                    out += esc;
-                    break;
-            }
-        }
-        else {
-            out += pyConsume(s);
-        }
-    }
-    if (s.pos >= s.text.length) {
-        throw new Error('Unterminated string literal');
-    }
-    pyConsume(s);
-    return out;
-}
-function pyParseNumber(s) {
-    const start = s.pos;
-    if (pyPeek(s) === '-' || pyPeek(s) === '+')
-        s.pos++;
-    while (/\d/.test(pyPeek(s)))
-        s.pos++;
-    if (pyPeek(s) === '.') {
-        s.pos++;
-        while (/\d/.test(pyPeek(s)))
-            s.pos++;
-    }
-    if (pyPeek(s) === 'e' || pyPeek(s) === 'E') {
-        s.pos++;
-        if (pyPeek(s) === '-' || pyPeek(s) === '+')
-            s.pos++;
-        while (/\d/.test(pyPeek(s)))
-            s.pos++;
-    }
-    const literal = s.text.slice(start, s.pos);
-    const n = Number(literal);
-    if (Number.isNaN(n) || literal.length === 0) {
-        throw new Error(`Invalid number literal: ${JSON.stringify(literal)}`);
-    }
-    return n;
-}
-function pyParseIdentifier(s) {
-    if (!/[A-Za-z_]/.test(pyPeek(s))) {
-        throw new Error(`Expected identifier, got ${JSON.stringify(pyPeek(s))}`);
-    }
-    const start = s.pos;
-    while (/[\w]/.test(pyPeek(s)))
-        s.pos++;
-    return s.text.slice(start, s.pos);
-}
-// Identifier-as-string fallback: any bare word that isn't `True`/`False`/`None`
-// is returned as a string, so `[get_weather(city=Paris)]` still produces
-// `{ city: "Paris" }`. Side-effect: lowercase `null` / `true` / `false` from
-// JS-trained models also coerce to strings — validate against your tool schema.
-function pyParseValue(s) {
-    pySkipWs(s);
-    const c = pyPeek(s);
-    if (c === '"' || c === "'")
-        return pyParseString(s);
-    if (c === '[')
-        return pyParseList(s);
-    if (c === '{')
-        return pyParseDict(s);
-    if (c === '-' || c === '+' || /\d/.test(c))
-        return pyParseNumber(s);
-    if (/[A-Za-z_]/.test(c)) {
-        const id = pyParseIdentifier(s);
-        if (id === 'True')
-            return true;
-        if (id === 'False')
-            return false;
-        if (id === 'None')
-            return null;
-        return id;
-    }
-    throw new Error(`Unexpected character: ${JSON.stringify(c)}`);
-}
-// Drives `parseItem, sep, parseItem, sep, ..., close` loops with trailing-
-// comma tolerance. Assumes the open delimiter was already consumed.
-function pyParseDelimited(s, close, context, parseItem) {
-    pySkipWs(s);
-    if (pyPeek(s) === close) {
-        pyConsume(s);
-        return;
-    }
-    for (;;) {
-        pySkipWs(s);
-        parseItem();
-        pySkipWs(s);
-        const sep = pyPeek(s);
-        if (sep === ',') {
-            pyConsume(s);
-            pySkipWs(s);
-            if (pyPeek(s) === close) {
-                pyConsume(s);
-                return;
-            }
-        }
-        else if (sep === close) {
-            pyConsume(s);
-            return;
-        }
-        else {
-            throw new Error(`Expected , or ${close} in ${context}, got ${JSON.stringify(sep)}`);
-        }
-    }
-}
-function pyParseList(s) {
-    pyConsume(s);
-    const items = [];
-    pyParseDelimited(s, ']', 'list', () => {
-        items.push(pyParseValue(s));
-    });
-    return items;
-}
-function pyParseDict(s) {
-    pyConsume(s);
-    const obj = {};
-    pyParseDelimited(s, '}', 'dict', () => {
-        const c = pyPeek(s);
-        let key;
-        if (c === '"' || c === "'")
-            key = pyParseString(s);
-        else if (/[A-Za-z_]/.test(c))
-            key = pyParseIdentifier(s);
-        else
-            throw new Error(`Expected dict key, got ${JSON.stringify(c)}`);
-        pySkipWs(s);
-        if (pyConsume(s) !== ':') {
-            throw new Error(`Expected : after dict key "${key}"`);
-        }
-        obj[key] = pyParseValue(s);
-    });
-    return obj;
-}
-function pyParseArgList(s) {
-    const args = {};
-    pyParseDelimited(s, ')', 'args', () => {
-        const key = pyParseIdentifier(s);
-        pySkipWs(s);
-        if (pyConsume(s) !== '=') {
-            throw new Error(`Expected = after arg name "${key}"`);
-        }
-        args[key] = pyParseValue(s);
-    });
-    return args;
-}
-function pyParseCallList(text) {
-    const s = { text, pos: 0 };
-    pySkipWs(s);
-    if (pyConsume(s) !== '[') {
-        throw new Error('Expected [ at start of call list');
-    }
-    const calls = [];
-    pyParseDelimited(s, ']', 'call list', () => {
-        const name = pyParseIdentifier(s);
-        pySkipWs(s);
-        if (pyConsume(s) !== '(') {
-            throw new Error(`Expected ( after call name "${name}"`);
-        }
-        calls.push({ name, arguments: pyParseArgList(s) });
-    });
-    return calls;
-}
-export function parsePythonicFormat(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    const slice = locatePythonicCallList(text);
-    if (slice === null) {
-        return { matched: false, toolCalls, errors };
-    }
-    let calls;
-    try {
-        calls = pyParseCallList(slice);
-    }
-    catch (error) {
-        errors.push({
-            code: 'PARSE_ERROR',
-            message: `Failed to parse Pythonic tool call list: ${error instanceof Error ? error.message : String(error)}`,
-            raw: slice
-        });
-        return { matched: true, toolCalls, errors };
-    }
-    for (const call of calls) {
-        const raw = `${call.name}(${JSON.stringify(call.arguments)})`;
-        const validation = validateToolArguments(call.name, call.arguments, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({ ...validation.error, raw });
-            continue;
-        }
-        toolCalls.push({
-            id: generateStableToolCallId(call.name, call.arguments),
-            name: call.name,
-            arguments: call.arguments,
-            raw
-        });
-    }
-    return { matched: true, toolCalls, errors };
-}

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

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

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

@@ -1,124 +0,0 @@
-import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
-// Coerce raw parameter text to the type declared in the tool's JSON schema.
-// String values are raw (not JSON-quoted); arrays/objects are valid JSON.
-function coerceParamValue(raw, schema) {
-    const trimmed = raw.trim();
-    if (!schema?.type)
-        return trimmed;
-    switch (schema.type) {
-        case 'number': {
-            if (trimmed.length === 0)
-                throw new Error(`invalid numeric value: ""`);
-            const n = Number(trimmed);
-            if (Number.isNaN(n))
-                throw new Error(`invalid numeric value: "${trimmed}"`);
-            return n;
-        }
-        case 'integer': {
-            if (trimmed.length === 0)
-                throw new Error(`invalid integer value: ""`);
-            const n = Number(trimmed);
-            if (Number.isNaN(n) || !Number.isInteger(n))
-                throw new Error(`invalid integer value: "${trimmed}"`);
-            return n;
-        }
-        case 'boolean': {
-            // Qwen3.5/3.6 intermittently emit Python-style capitalised booleans
-            // (`True`/`False`); accept any casing so a valid call isn't dropped.
-            const v = trimmed.toLowerCase();
-            if (v === 'true')
-                return true;
-            if (v === 'false')
-                return false;
-            throw new Error(`invalid boolean value: "${trimmed}"`);
-        }
-        case 'array':
-        case 'object':
-            return JSON.parse(trimmed);
-        default:
-            return trimmed;
-    }
-}
-// Parses Qwen3.5/3.6 Pythonic-XML tool-call format:
-//   <tool_call>
-//   <function=NAME>
-//   <parameter=KEY>VALUE</parameter>
-//   </function>
-//   </tool_call>
-// String parameter values are raw text (not JSON-quoted); arrays/objects
-// are JSON. Type coercion uses the tool schema; unknown params pass through.
-export function parseQwen35Format(text, tools) {
-    const toolCalls = [];
-    const errors = [];
-    if (!text.includes('<tool_call>')) {
-        return { matched: false, toolCalls, errors };
-    }
-    const outerRegex = /<tool_call>([\s\S]*?)<\/tool_call>/g;
-    const outerMatches = Array.from(text.matchAll(outerRegex));
-    if (outerMatches.length === 0)
-        return { matched: false, toolCalls, errors };
-    // If no match contains XML function syntax, check if this is JSON format
-    // (defer to hermes) or just malformed content (surface as PARSE_ERROR).
-    if (!outerMatches.some((m) => m[1].includes('<function='))) {
-        const looksLikeJson = outerMatches.some((m) => {
-            const inner = m[1].trim();
-            return inner.startsWith('{') || inner.startsWith('[');
-        });
-        if (looksLikeJson)
-            return { matched: false, toolCalls, errors };
-        return {
-            matched: true,
-            toolCalls,
-            errors: outerMatches.map((m) => ({
-                code: 'PARSE_ERROR',
-                message: 'Qwen3.5 tool call missing <function=NAME>...</function>',
-                raw: m[1].trim()
-            }))
-        };
-    }
-    for (const outerMatch of outerMatches) {
-        const inner = outerMatch[1].trim();
-        const fnMatch = /<function=([^>\s]+)\s*>([\s\S]*?)<\/function>/i.exec(inner);
-        if (!fnMatch) {
-            errors.push({
-                code: 'PARSE_ERROR',
-                message: 'Qwen3.5 tool call missing <function=NAME>...</function>',
-                raw: inner
-            });
-            continue;
-        }
-        const name = fnMatch[1].trim();
-        const paramsBlock = fnMatch[2];
-        const tool = tools.find((t) => t.name === name);
-        const schemaProperties = tool?.parameters?.properties ?? {};
-        const args = {};
-        let parseError;
-        try {
-            const paramRegex = /<parameter=([^>\s]+)\s*>([\s\S]*?)<\/parameter>/gi;
-            let pm;
-            while ((pm = paramRegex.exec(paramsBlock)) !== null) {
-                const paramName = pm[1].trim();
-                args[paramName] = coerceParamValue(pm[2], schemaProperties[paramName]);
-            }
-        }
-        catch (err) {
-            parseError = err instanceof Error ? err.message : String(err);
-        }
-        if (parseError !== undefined) {
-            errors.push({ code: 'PARSE_ERROR', message: parseError, raw: inner });
-            continue;
-        }
-        const validation = validateToolArguments(name, args, tools);
-        if (!validation.isValid && validation.error) {
-            errors.push({ ...validation.error, raw: inner });
-            continue;
-        }
-        toolCalls.push({
-            id: generateStableToolCallId(name, args),
-            name,
-            arguments: args,
-            raw: inner
-        });
-    }
-    return { matched: true, toolCalls, errors };
-}

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

@@ -1,18 +0,0 @@
-import type { Tool, ToolCall, ToolCallError } from '../../../schemas/index.js';
-export type ParserResult = {
-    matched: boolean;
-    toolCalls: ToolCall[];
-    errors: ToolCallError[];
-};
-export declare function stripThinkingBlocks(text: string): string;
-export declare function generateStableToolCallId(name: string, args: Record<string, unknown>): string;
-export declare function isValidToolCall(obj: unknown): obj is {
-    name: string;
-    arguments: Record<string, unknown>;
-    id?: string;
-};
-export declare function validateToolArguments(toolName: string, args: Record<string, unknown>, tools: Tool[]): {
-    isValid: boolean;
-    error?: ToolCallError;
-};
-//# sourceMappingURL=shared.d.ts.map

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

@@ -1,52 +0,0 @@
-export function stripThinkingBlocks(text) {
-    return text.replace(/<think>[\s\S]*?<\/think>/gi, '');
-}
-let toolCallSequence = 0;
-export function generateStableToolCallId(name, args) {
-    const content = `${name}:${JSON.stringify(args)}`;
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-        const char = content.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash;
-    }
-    const sequence = toolCallSequence++;
-    return `call_${Math.abs(hash).toString(36)}_${sequence}`;
-}
-export function isValidToolCall(obj) {
-    if (!obj || typeof obj !== 'object') {
-        return false;
-    }
-    if (!('name' in obj) || typeof obj.name !== 'string') {
-        return false;
-    }
-    if (!('arguments' in obj) || typeof obj.arguments !== 'object' || obj.arguments === null) {
-        return false;
-    }
-    return true;
-}
-export function validateToolArguments(toolName, args, tools) {
-    const tool = tools.find((t) => t.name === toolName);
-    if (!tool) {
-        return {
-            isValid: false,
-            error: {
-                code: 'UNKNOWN_TOOL',
-                message: `Tool "${toolName}" not found in available tools`
-            }
-        };
-    }
-    const required = tool.parameters.required || [];
-    for (const requiredParam of required) {
-        if (!(requiredParam in args)) {
-            return {
-                isValid: false,
-                error: {
-                    code: 'VALIDATION_ERROR',
-                    message: `Missing required parameter "${requiredParam}" for tool "${toolName}"`
-                }
-            };
-        }
-    }
-    return { isValid: true };
-}

package/dist/server/utils/worker-lock.js

@@ -1,67 +0,0 @@
-import fs from 'bare-fs';
-import path from 'bare-path';
-import os from 'bare-os';
-import { getServerLogger } from '../../logging/index.js';
-import { getQvacPath } from '../../server/utils/qvac-paths.js';
-const logger = getServerLogger();
-const LOCK_FILENAME = '.worker.lock';
-function getLockFilePath() {
-    return getQvacPath(LOCK_FILENAME);
-}
-function isProcessAlive(pid) {
-    try {
-        os.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function readLockFile(lockPath) {
-    try {
-        if (!fs.existsSync(lockPath))
-            return null;
-        const raw = fs.readFileSync(lockPath, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function acquireWorkerLock() {
-    const lockPath = getLockFilePath();
-    const existing = readLockFile(lockPath);
-    if (existing) {
-        if (isProcessAlive(existing.pid)) {
-            logger.warn(`Another worker (PID ${existing.pid}) is still running — lock file exists at ${lockPath}`);
-        }
-        else {
-            logger.warn(`Stale lock file detected (PID ${existing.pid} is dead, started ${existing.startedAt}). Removing.`);
-        }
-    }
-    const content = {
-        pid: os.pid(),
-        startedAt: new Date().toISOString()
-    };
-    try {
-        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-        fs.writeFileSync(lockPath, JSON.stringify(content));
-        logger.debug(`Worker lock acquired (PID ${os.pid()})`);
-    }
-    catch (error) {
-        logger.error('Failed to write worker lock file:', error instanceof Error ? error.message : String(error));
-    }
-}
-export function releaseWorkerLock() {
-    const lockPath = getLockFilePath();
-    try {
-        const existing = readLockFile(lockPath);
-        if (existing && existing.pid === os.pid()) {
-            fs.unlinkSync(lockPath);
-            logger.debug('Worker lock released');
-        }
-    }
-    catch {
-        // Best-effort — may already be gone
-    }
-}

package/dist/server/worker-core.d.ts

@@ -1,23 +0,0 @@
-export declare function initializeWorkerCore(): {
-    hasRPCConfig: boolean;
-};
-export declare function ensureRPCSetup(): void;
-export declare function isCoreInitialized(): boolean;
-export type BareDirectShutdownReason = 'signal' | 'rpc-close' | 'uncaught-exception' | 'unhandled-rejection' | 'ipc-disconnect';
-/**
- * Pre-terminate cleanup, callable while the worker is still alive.
- *
- * On platforms where the worker lives in the same OS process as the JS host
- * (i.e. mobile via react-native-bare-kit Worklet), `Bare.exit()` would
- * kill the entire app. This path runs the same registry/model cleanup as
- * `shutdownBareDirectWorker` but skips the lock release + exit, leaving the
- * caller (typically the SDK client about to call `worklet.terminate()`)
- * responsible for tearing the worker down.
- *
- * Critical for clean termination: addons hold static state with js_ref_t
- * handles into the current V8 isolate; without this cleanup, those refs
- * survive into the next worklet's isolate and crash on first access.
- */
-export declare function cleanupForTerminate(): Promise<void>;
-export declare function shutdownBareDirectWorker(reason: BareDirectShutdownReason): Promise<void>;
-//# sourceMappingURL=worker-core.d.ts.map