@qvac/sdk 0.3.0 → 0.4.0

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

@@ -0,0 +1,244 @@
+let toolCallSequence = 0;
+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}`;
+}
+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;
+}
+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 };
+}
+function parseGemmaFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed &&
+            typeof parsed === "object" &&
+            "tool_calls" in parsed &&
+            Array.isArray(parsed.tool_calls)) {
+            for (const callItem of parsed.tool_calls) {
+                if (!isValidToolCall(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),
+                });
+            }
+        }
+    }
+    catch {
+        // Not Gemma format, continue to next parser
+    }
+    return { toolCalls, errors };
+}
+function parseQwenFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    const toolCallRegex = /<tool_call>\s*({[\s\S]*?})\s*<\/tool_call>/g;
+    const matches = Array.from(text.matchAll(toolCallRegex));
+    for (const match of matches) {
+        try {
+            const callJson = match[1];
+            if (!callJson)
+                continue;
+            const trimmedJson = callJson.trim();
+            const callItem = JSON.parse(trimmedJson);
+            if (!isValidToolCall(callItem)) {
+                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,
+            });
+        }
+        catch (error) {
+            errors.push({
+                code: "PARSE_ERROR",
+                message: `Failed to parse Qwen tool call: ${error instanceof Error ? error.message : String(error)}`,
+                raw: match[1],
+            });
+        }
+    }
+    return { toolCalls, errors };
+}
+function parseLlamacppFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    try {
+        const parsedItem = JSON.parse(text);
+        if (isValidToolCall(parsedItem)) {
+            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,
+                });
+            }
+        }
+    }
+    catch {
+        // Not valid JSON format
+    }
+    return { toolCalls, errors };
+}
+function parseGenericFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    const jsonObjectRegex = /\{[\s\S]*?"name"[\s\S]*?"arguments"[\s\S]*?\}/g;
+    let match;
+    while ((match = jsonObjectRegex.exec(text)) !== null) {
+        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 { toolCalls, errors };
+}
+export function parseToolCalls(text, tools) {
+    if (!tools || tools.length === 0) {
+        return { toolCalls: [], errors: [] };
+    }
+    let result = parseGemmaFormat(text, tools);
+    if (result.toolCalls.length > 0) {
+        return result;
+    }
+    result = parseQwenFormat(text, tools);
+    if (result.toolCalls.length > 0) {
+        return result;
+    }
+    result = parseLlamacppFormat(text, tools);
+    if (result.toolCalls.length > 0) {
+        return result;
+    }
+    if (text.includes("<tool_call>")) {
+        return { toolCalls: [], errors: [] };
+    }
+    result = parseGenericFormat(text, tools);
+    return result;
+}
+export function convertToolsToGrammar(tools) {
+    const toolSchemas = tools.map((tool) => {
+        const properties = {};
+        for (const [key, value] of Object.entries(tool.parameters.properties)) {
+            properties[key] = {
+                type: value.type,
+                ...(value.description && { description: value.description }),
+                ...(value.enum && { enum: value.enum }),
+            };
+        }
+        return {
+            type: "object",
+            properties: {
+                name: { type: "string", const: tool.name },
+                arguments: {
+                    type: "object",
+                    properties,
+                    required: tool.parameters.required || [],
+                },
+            },
+            required: ["name", "arguments"],
+        };
+    });
+    const grammar = {
+        oneOf: toolSchemas,
+    };
+    return JSON.stringify(grammar);
+}

package/dist/utils/errors-base.d.ts

@@ -0,0 +1,3 @@
+import type { QvacErrorOptions } from "@qvac/error";
+export declare const createErrorOptions: (code: number, adds?: string | (string | number)[], cause?: unknown) => QvacErrorOptions;
+//# sourceMappingURL=errors-base.d.ts.map

package/dist/utils/errors-base.js

@@ -0,0 +1,13 @@
+export const createErrorOptions = (code, adds, cause) => {
+    const options = { code };
+    if (adds !== undefined) {
+        options.adds = adds;
+    }
+    if (cause !== undefined) {
+        options.cause =
+            cause instanceof Error
+                ? cause
+                : new Error(typeof cause === "string" ? cause : JSON.stringify(cause));
+    }
+    return options;
+};

package/dist/utils/errors-client.d.ts

@@ -0,0 +1,107 @@
+import { QvacErrorBase } from "@qvac/error";
+export declare class InvalidResponseError extends QvacErrorBase {
+    constructor(expected: string, cause?: unknown);
+}
+export declare class InvalidOperationError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class StreamEndedError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class NoDataReceivedError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class InvalidAudioChunkError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class InvalidToolsArrayError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class InvalidToolSchemaError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class RPCNoHandlerError extends QvacErrorBase {
+    constructor(requestType: string, cause?: unknown);
+}
+export declare class RPCRequestNotSentError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class RPCResponseStreamNotCreatedError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class RPCConnectionFailedError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class UnknownRequestTypeError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class ProviderStartFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class ProviderStopFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class DelegateNoFinalResponseError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class DelegateProviderError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class DelegateConnectionFailedError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class SDKNotFoundInNodeModulesError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class WorkerFileNotFoundError extends QvacErrorBase {
+    constructor(workerPath: string, cause?: unknown);
+}
+export declare class ModelUnloadFailedError extends QvacErrorBase {
+    constructor(modelId?: string, cause?: unknown);
+}
+export declare class EmbedFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class TranscriptionFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class TranslationFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class CancelFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class RAGSaveFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class RAGSearchFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class RAGDeleteFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class DownloadAssetFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class DownloadCancelledError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class ChecksumValidationFailedError extends QvacErrorBase {
+    constructor(fileName: string, cause?: unknown);
+}
+export declare class HTTPError extends QvacErrorBase {
+    constructor(status: number, statusText: string, cause?: unknown);
+}
+export declare class ModelLoadFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class DeleteCacheFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class InvalidDeleteCacheParamsError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class SetConfigFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+//# sourceMappingURL=errors-client.d.ts.map

package/dist/utils/errors-client.js

@@ -0,0 +1,186 @@
+import { QvacErrorBase } from "@qvac/error";
+import { SDK_CLIENT_ERROR_CODES } from "../schemas/sdk-errors-client.js";
+import { createErrorOptions } from "./errors-base.js";
+// ============== Response Validation Errors ==============
+export class InvalidResponseError extends QvacErrorBase {
+    constructor(expected, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_RESPONSE_TYPE, [expected], cause));
+    }
+}
+export class InvalidOperationError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_OPERATION_IN_RESPONSE, undefined, cause));
+    }
+}
+export class StreamEndedError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.STREAM_ENDED_WITHOUT_RESPONSE, undefined, cause));
+    }
+}
+export class NoDataReceivedError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.NO_DATA_RECEIVED, undefined, cause));
+    }
+}
+export class InvalidAudioChunkError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_AUDIO_CHUNK_TYPE, undefined, cause));
+    }
+}
+export class InvalidToolsArrayError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_TOOLS_ARRAY, undefined, cause));
+    }
+}
+export class InvalidToolSchemaError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_TOOL_SCHEMA, [details], cause));
+    }
+}
+// ============== RPC Communication Errors ==============
+export class RPCNoHandlerError extends QvacErrorBase {
+    constructor(requestType, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_NO_HANDLER, [requestType], cause));
+    }
+}
+export class RPCRequestNotSentError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_REQUEST_NOT_SENT, undefined, cause));
+    }
+}
+export class RPCResponseStreamNotCreatedError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_RESPONSE_STREAM_NOT_CREATED, undefined, cause));
+    }
+}
+export class RPCConnectionFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_CONNECTION_FAILED, [details], cause));
+    }
+}
+export class UnknownRequestTypeError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.UNKNOWN_REQUEST_TYPE, undefined, cause));
+    }
+}
+// ============== Provider/Delegation Errors ==============
+export class ProviderStartFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.PROVIDER_START_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class ProviderStopFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.PROVIDER_STOP_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DelegateNoFinalResponseError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.DELEGATE_NO_FINAL_RESPONSE, undefined, cause));
+    }
+}
+export class DelegateProviderError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.DELEGATE_PROVIDER_ERROR, [details], cause));
+    }
+}
+export class DelegateConnectionFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.DELEGATE_CONNECTION_FAILED, [details], cause));
+    }
+}
+// ============== Build/Bundle Errors ==============
+export class SDKNotFoundInNodeModulesError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.SDK_NOT_FOUND_IN_NODE_MODULES, undefined, cause));
+    }
+}
+export class WorkerFileNotFoundError extends QvacErrorBase {
+    constructor(workerPath, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_FILE_NOT_FOUND, [workerPath], cause));
+    }
+}
+// ============== Operation Errors (Client-side wrappers for server operations) ==============
+// These are used by client API to throw errors based on server responses
+// They reference server error codes but are thrown on client side
+import { SDK_SERVER_ERROR_CODES } from "../schemas/sdk-errors-server.js";
+export class ModelUnloadFailedError extends QvacErrorBase {
+    constructor(modelId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_UNLOAD_FAILED, modelId ? [modelId] : undefined, cause));
+    }
+}
+export class EmbedFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.EMBED_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class TranscriptionFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TRANSCRIPTION_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class TranslationFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TRANSLATION_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class CancelFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CANCEL_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGSaveFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_SAVE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGSearchFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_SEARCH_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGDeleteFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_DELETE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DownloadAssetFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DOWNLOAD_ASSET_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DownloadCancelledError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DOWNLOAD_CANCELLED, undefined, cause));
+    }
+}
+export class ChecksumValidationFailedError extends QvacErrorBase {
+    constructor(fileName, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CHECKSUM_VALIDATION_FAILED, [fileName], cause));
+    }
+}
+export class HTTPError extends QvacErrorBase {
+    constructor(status, statusText, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.HTTP_ERROR, [status, statusText], cause));
+    }
+}
+export class ModelLoadFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_LOAD_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DeleteCacheFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DELETE_CACHE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class InvalidDeleteCacheParamsError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.INVALID_DELETE_CACHE_PARAMS, undefined, cause));
+    }
+}
+export class SetConfigFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.SET_CONFIG_FAILED, details ? [details] : undefined, cause));
+    }
+}