@qvac/sdk 1.0.0 → 1.1.0

package/dist/schemas/transcription.d.ts

@@ -15,6 +15,7 @@ export declare const transcribeParamsSchema: z.ZodObject<{
         type: z.ZodLiteral<"filePath">;
         value: z.ZodString;
     }, z.core.$strip>], "type">;
+    prompt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const transcribeStreamRequestSchema: z.ZodObject<{
     modelId: z.ZodString;
@@ -25,6 +26,7 @@ export declare const transcribeStreamRequestSchema: z.ZodObject<{
         type: z.ZodLiteral<"filePath">;
         value: z.ZodString;
     }, z.core.$strip>], "type">;
+    prompt: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"transcribeStream">;
 }, z.core.$strip>;
 export declare const transcribeStreamResponseSchema: z.ZodObject<{
@@ -38,6 +40,7 @@ export type TranscribeParams = z.infer<typeof transcribeParamsSchema>;
 export type TranscribeClientParams = {
     modelId: string;
     audioChunk: string | Buffer;
+    prompt?: string;
 };
 export type TranscribeStreamRequest = z.infer<typeof transcribeStreamRequestSchema>;
 export type TranscribeStreamResponse = z.infer<typeof transcribeStreamResponseSchema>;

package/dist/schemas/transcription.js

@@ -12,6 +12,7 @@ export const audioInputSchema = z.discriminatedUnion("type", [
 export const transcribeParamsSchema = z.object({
     modelId: z.string(),
     audioChunk: audioInputSchema,
+    prompt: z.string().optional(),
 });
 // Streaming Transcribe Schema (for real-time audio streaming)
 export const transcribeStreamRequestSchema = transcribeParamsSchema.extend({

package/dist/schemas/whispercpp-config.d.ts

@@ -9,16 +9,65 @@ export declare const whisperConfigSchema: z.ZodObject<{
         json: "json";
     }>>;
     min_seconds: z.ZodDefault<z.ZodNumber>;
-    max_seconds: z.ZodDefault<z.ZodNumber>;
-    audio_format: z.ZodDefault<z.ZodString>;
     update_frequency: z.ZodDefault<z.ZodString>;
-    vadConfig: z.ZodOptional<z.ZodObject<{
-        vad_threshold: z.ZodOptional<z.ZodNumber>;
-        vad_min_speech_duration_ms: z.ZodOptional<z.ZodNumber>;
-        vad_min_silence_duration_ms: z.ZodOptional<z.ZodNumber>;
-        vad_max_speech_duration_s: z.ZodOptional<z.ZodNumber>;
-        vad_speech_pad_ms: z.ZodOptional<z.ZodNumber>;
-        vad_samples_overlap: z.ZodOptional<z.ZodNumber>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        greedy: "greedy";
+        beam_search: "beam_search";
+    }>>;
+    n_threads: z.ZodOptional<z.ZodNumber>;
+    n_max_text_ctx: z.ZodOptional<z.ZodNumber>;
+    offset_ms: z.ZodOptional<z.ZodNumber>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+    audio_ctx: z.ZodOptional<z.ZodNumber>;
+    translate: z.ZodOptional<z.ZodBoolean>;
+    no_context: z.ZodOptional<z.ZodBoolean>;
+    no_timestamps: z.ZodOptional<z.ZodBoolean>;
+    single_segment: z.ZodOptional<z.ZodBoolean>;
+    print_special: z.ZodOptional<z.ZodBoolean>;
+    print_progress: z.ZodOptional<z.ZodBoolean>;
+    print_realtime: z.ZodOptional<z.ZodBoolean>;
+    print_timestamps: z.ZodOptional<z.ZodBoolean>;
+    token_timestamps: z.ZodOptional<z.ZodBoolean>;
+    thold_pt: z.ZodOptional<z.ZodNumber>;
+    thold_ptsum: z.ZodOptional<z.ZodNumber>;
+    max_len: z.ZodOptional<z.ZodNumber>;
+    split_on_word: z.ZodOptional<z.ZodBoolean>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    debug_mode: z.ZodOptional<z.ZodBoolean>;
+    tdrz_enable: z.ZodOptional<z.ZodBoolean>;
+    suppress_regex: z.ZodOptional<z.ZodString>;
+    initial_prompt: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    detect_language: z.ZodOptional<z.ZodBoolean>;
+    suppress_blank: z.ZodOptional<z.ZodBoolean>;
+    suppress_nst: z.ZodOptional<z.ZodBoolean>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    length_penalty: z.ZodOptional<z.ZodNumber>;
+    temperature_inc: z.ZodOptional<z.ZodNumber>;
+    entropy_thold: z.ZodOptional<z.ZodNumber>;
+    logprob_thold: z.ZodOptional<z.ZodNumber>;
+    greedy_best_of: z.ZodOptional<z.ZodNumber>;
+    beam_search_beam_size: z.ZodOptional<z.ZodNumber>;
+    vadModelPath: z.ZodOptional<z.ZodString>;
+    vad_params: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodOptional<z.ZodNumber>;
+        min_speech_duration_ms: z.ZodOptional<z.ZodNumber>;
+        min_silence_duration_ms: z.ZodOptional<z.ZodNumber>;
+        max_speech_duration_s: z.ZodOptional<z.ZodNumber>;
+        speech_pad_ms: z.ZodOptional<z.ZodNumber>;
+        samples_overlap: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    max_seconds: z.ZodOptional<z.ZodNumber>;
+    chunk_length_s: z.ZodOptional<z.ZodNumber>;
+    audio_format: z.ZodOptional<z.ZodString>;
+    contextParams: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        use_gpu: z.ZodOptional<z.ZodBoolean>;
+        flash_attn: z.ZodOptional<z.ZodBoolean>;
+        gpu_device: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    miscConfig: z.ZodOptional<z.ZodObject<{
+        caption_enabled: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WhisperConfig = z.infer<typeof whisperConfigSchema>;

package/dist/schemas/whispercpp-config.js

@@ -1,18 +1,72 @@
 import { z } from "zod";
-const vadConfigSchema = z.object({
-    vad_threshold: z.number().optional(),
-    vad_min_speech_duration_ms: z.number().optional(),
-    vad_min_silence_duration_ms: z.number().optional(),
-    vad_max_speech_duration_s: z.number().optional(),
-    vad_speech_pad_ms: z.number().optional(),
-    vad_samples_overlap: z.number().optional(),
-});
+const vadParamsSchema = z
+    .object({
+    threshold: z.number().optional(),
+    min_speech_duration_ms: z.number().optional(),
+    min_silence_duration_ms: z.number().optional(),
+    max_speech_duration_s: z.number().optional(),
+    speech_pad_ms: z.number().optional(),
+    samples_overlap: z.number().optional(),
+})
+    .optional();
+const contextParamsSchema = z
+    .object({
+    model: z.string().optional(),
+    use_gpu: z.boolean().optional(),
+    flash_attn: z.boolean().optional(),
+    gpu_device: z.number().optional(),
+})
+    .optional();
+const miscConfigSchema = z
+    .object({
+    caption_enabled: z.boolean().optional(),
+})
+    .optional();
 export const whisperConfigSchema = z.object({
     mode: z.enum(["caption", "batch"]).default("caption"),
     output_format: z.enum(["plaintext", "json"]).default("plaintext"),
     min_seconds: z.number().default(1),
-    max_seconds: z.number().default(30),
-    audio_format: z.string().default("wav"),
     update_frequency: z.string().default("on_end"),
-    vadConfig: vadConfigSchema.optional(),
+    strategy: z.enum(["greedy", "beam_search"]).optional(),
+    n_threads: z.number().int().optional(),
+    n_max_text_ctx: z.number().int().optional(),
+    offset_ms: z.number().int().optional(),
+    duration_ms: z.number().int().optional(),
+    audio_ctx: z.number().int().optional(),
+    translate: z.boolean().optional(),
+    no_context: z.boolean().optional(),
+    no_timestamps: z.boolean().optional(),
+    single_segment: z.boolean().optional(),
+    print_special: z.boolean().optional(),
+    print_progress: z.boolean().optional(),
+    print_realtime: z.boolean().optional(),
+    print_timestamps: z.boolean().optional(),
+    token_timestamps: z.boolean().optional(),
+    thold_pt: z.number().optional(),
+    thold_ptsum: z.number().optional(),
+    max_len: z.number().int().optional(),
+    split_on_word: z.boolean().optional(),
+    max_tokens: z.number().int().optional(),
+    debug_mode: z.boolean().optional(),
+    tdrz_enable: z.boolean().optional(),
+    suppress_regex: z.string().optional(),
+    initial_prompt: z.string().optional(),
+    language: z.string().optional(),
+    detect_language: z.boolean().optional(),
+    suppress_blank: z.boolean().optional(),
+    suppress_nst: z.boolean().optional(),
+    temperature: z.number().optional(),
+    length_penalty: z.number().optional(),
+    temperature_inc: z.number().optional(),
+    entropy_thold: z.number().optional(),
+    logprob_thold: z.number().optional(),
+    greedy_best_of: z.number().int().optional(),
+    beam_search_beam_size: z.number().int().optional(),
+    vadModelPath: z.string().optional(),
+    vad_params: vadParamsSchema,
+    max_seconds: z.number().optional(),
+    chunk_length_s: z.number().optional(),
+    audio_format: z.string().optional(),
+    contextParams: contextParamsSchema,
+    miscConfig: miscConfigSchema,
 });

package/dist/server/bare/addons/llamacpp/handlers/completion-stream.js

@@ -2,7 +2,8 @@ import {} from "../../../../../schemas/index.js";
 import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
 import { findMatchingCache, getCurrentCacheInfo, renameCacheFile, getCacheFilePath, extractSystemPrompt, generateConfigHash, customCacheExists, } from "../kv-cache-utils";
 import fs from "bare-fs";
-import { parseToolCalls, convertToolsToGrammar, } from "../../../../utils/tool-parser.js";
+import { insertToolsIntoHistory, setupToolGrammar, checkForToolEvents, } from "../../../../utils/tool-integration.js";
+import { parseToolCalls } from "../../../../utils/tool-parser.js";
 function transformMessage(message) {
     const transformed = [];
     // Check if it's a tool definition (has type: "function")
@@ -74,7 +75,6 @@ function prepareMessagesForCache(cachePathToUse, cacheExists, history) {
 }
 async function* processModelResponse(model, messagesToSend, shouldSaveCache, tools) {
     const response = await model.run(messagesToSend);
-    // Create a promise that rejects when onError is triggered
     let rejectOnError = null;
     const errorPromise = new Promise((_, reject) => {
         rejectOnError = reject;
@@ -86,43 +86,23 @@ async function* processModelResponse(model, messagesToSend, shouldSaveCache, too
     });
     const iterator = response.iterate();
     let accumulatedText = "";
-    const emittedToolCalls = new Set();
+    const emittedToolCallPositions = new Set();
+    let toolCallsResult = [];
     try {
         while (true) {
-            // Race between getting the next token and an error occurring
             const result = await Promise.race([iterator.next(), errorPromise]);
             if (result.done) {
                 break;
             }
             const token = result.value;
             accumulatedText += token;
+            yield { token };
             if (tools && tools.length > 0) {
-                const { toolCalls, errors } = parseToolCalls(accumulatedText, tools);
-                for (const call of toolCalls) {
-                    if (!emittedToolCalls.has(call.id)) {
-                        emittedToolCalls.add(call.id);
-                        const toolCallEvent = {
-                            type: "toolCall",
-                            call,
-                        };
-                        yield { token, toolCallEvent };
-                        continue;
-                    }
-                }
-                for (const error of errors) {
-                    const errorKey = `error:${error.code}:${error.message}`;
-                    if (!emittedToolCalls.has(errorKey)) {
-                        emittedToolCalls.add(errorKey);
-                        const toolCallEvent = {
-                            type: "toolCallError",
-                            error,
-                        };
-                        yield { token, toolCallEvent };
-                        continue;
-                    }
+                const toolEvents = checkForToolEvents(accumulatedText, token, tools, emittedToolCallPositions);
+                for (const toolEvent of toolEvents) {
+                    yield { token: "", toolCallEvent: toolEvent };
                 }
             }
-            yield { token };
         }
     }
     catch (error) {
@@ -133,6 +113,10 @@ async function* processModelResponse(model, messagesToSend, shouldSaveCache, too
             throw new Error(String(error));
         }
     }
+    if (tools && tools.length > 0) {
+        const { toolCalls } = parseToolCalls(accumulatedText, tools);
+        toolCallsResult = toolCalls;
+    }
     if (shouldSaveCache) {
         await model.run([{ role: "session", content: "save" }]);
     }
@@ -142,30 +126,16 @@ async function* processModelResponse(model, messagesToSend, shouldSaveCache, too
         tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
         cacheTokens: responseWithStats.stats?.CacheTokens ?? 0,
     };
-    const { toolCalls } = parseToolCalls(accumulatedText, tools || []);
-    return { stats, toolCalls };
+    return { stats, toolCalls: toolCallsResult };
 }
 export async function* completion(params) {
     const { history, modelId, kvCache, tools } = params;
-    // Check if model was configured with tools support
     const modelConfig = getModelConfig(modelId);
     const toolsEnabled = modelConfig.tools === true;
     let historyWithTools = history;
     if (tools && tools.length > 0 && toolsEnabled) {
-        // Insert tools after system message (if exists) or at the beginning
-        const systemMsgIndex = history.findIndex((msg) => msg.role === "system");
-        if (systemMsgIndex >= 0) {
-            historyWithTools = [
-                ...history.slice(0, systemMsgIndex + 1),
-                ...tools,
-                ...history.slice(systemMsgIndex + 1),
-            ];
-        }
-        else {
-            historyWithTools = [...tools, ...history];
-        }
-        const grammar = convertToolsToGrammar(tools);
-        modelConfig.grammar = grammar;
+        historyWithTools = insertToolsIntoHistory(history, tools);
+        setupToolGrammar(modelConfig, tools);
     }
     const transformedHistory = transformMessages(historyWithTools);
     const model = getModel(modelId);

package/dist/server/bare/addons/whispercpp/create-model.js

@@ -23,11 +23,12 @@ function createFilesystemDLMimic(options) {
 }
 export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    // Handle VAD model path - now uses vadModelPath parameter for consistency
+    // Handle VAD model path
     let vadModelName = "";
     let vadDirPath = "./";
-    if (vadModelPath) {
-        const vadParsed = parseModelPath(vadModelPath);
+    const effectiveVadPath = vadModelPath || whisperConfig.vadModelPath;
+    if (effectiveVadPath) {
+        const vadParsed = parseModelPath(effectiveVadPath);
         vadDirPath = vadParsed.dirPath;
         vadModelName = vadParsed.basePath;
     }
@@ -45,11 +46,11 @@ export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPa
             stats: false,
         },
     };
+    const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
     const config = {
-        whisperConfig: {
-            ...whisperConfig,
-            vad_model: vadModelPath || "",
-        },
+        whisperConfig: whisperParams,
+        ...(contextParams && { contextParams }),
+        ...(miscConfig && { miscConfig }),
     };
     return new TranscriptionWhispercpp(args, config);
 }

package/dist/server/bare/addons/whispercpp/handlers/transcribe-stream.js

@@ -1,10 +1,24 @@
-import { getModel } from "../../../registry/model-registry.js";
+import { getModel, getModelConfig, updateModelConfig, } from "../../../registry/model-registry.js";
 import { Readable } from "bare-stream";
 import fs from "bare-fs";
 import { needsDecoding, decodeAudioToStream } from "../../../../utils/index.js";
 import {} from "../../../../../schemas/index.js";
 export async function* transcribe(params) {
     const model = getModel(params.modelId);
+    if (params.prompt && typeof model.reload === "function") {
+        const existingConfig = getModelConfig(params.modelId);
+        const updatedConfig = {
+            ...existingConfig,
+            initial_prompt: params.prompt,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { contextParams: _, miscConfig, ...whisperParams } = updatedConfig;
+        await model.reload({
+            whisperConfig: whisperParams,
+            ...(miscConfig && { miscConfig }),
+        });
+        updateModelConfig(params.modelId, updatedConfig);
+    }
     let audioStream;
     const audioChunk = params.audioChunk;
     switch (audioChunk.type) {

package/dist/server/bare/registry/model-registry.d.ts

@@ -25,6 +25,7 @@ export interface AnyModel {
         }>>;
         await(): Promise<void>;
     }>;
+    reload?(config: unknown): Promise<void>;
     unload?(): Promise<void>;
     addon?: AddonInterface;
 }
@@ -66,6 +67,7 @@ export declare function getModelInfo(id: string): {
     config: unknown;
 } | null;
 export declare function getModelConfig(id: string): unknown;
+export declare function updateModelConfig(id: string, config: unknown): void;
 export declare function clearRegistry(): void;
 export declare function getRegistryStats(): {
     totalModels: number;

package/dist/server/bare/registry/model-registry.js

@@ -80,6 +80,13 @@ export function getModelConfig(id) {
     }
     return entry.local.config;
 }
+export function updateModelConfig(id, config) {
+    const entry = modelRegistry.get(id);
+    if (!entry || !entry.local) {
+        throw new Error(`Model with ID "${id}" not found or is delegated`);
+    }
+    entry.local.config = config;
+}
 export function clearRegistry() {
     modelRegistry.clear();
     console.log("Model registry cleared");

package/dist/server/rpc/handlers/completion-stream.js

@@ -23,7 +23,6 @@ export async function* handleCompletionStream(request) {
             done = true;
         }
         else {
-            buffer += result.value.token;
             if (request.stream) {
                 yield {
                     type: "completionStream",
@@ -31,11 +30,14 @@ export async function* handleCompletionStream(request) {
                     toolCallEvent: result.value.toolCallEvent,
                 };
             }
+            else {
+                buffer += result.value.token;
+            }
         }
     }
     yield {
         type: "completionStream",
-        token: buffer,
+        token: request.stream ? "" : buffer,
         done: true,
         stats,
         toolCalls,

package/dist/server/rpc/handlers/load-model/http.js

@@ -27,11 +27,10 @@ async function validateCachedFile(modelPath, url, signal) {
             expectedSize = parseInt(response.headers.get("content-length") || "0");
         }
         catch (error) {
-            console.log(`⚠️ Could not get expected file size from HEAD request: ${String(error)}`);
-            console.log(`✅ Using cached HTTP model: ${modelPath}`);
-            return modelPath;
+            console.log(`⚠️ Could not get expected file size from HEAD request, will re-download: ${String(error)}`);
+            return null;
         }
-        if (expectedSize > 0 && localSize !== expectedSize) {
+        if (localSize !== expectedSize) {
             console.log(`📥 Cached file size mismatch. Expected: ${expectedSize}, Found: ${localSize}. Re-downloading...`);
             return null;
         }
@@ -64,6 +63,13 @@ async function performHttpDownload(url, modelPath, downloadKey, progressCallback
     const headers = {
         "User-Agent": "qvac-sdk",
     };
+    const isPresignedUrl = url.includes("X-Amz-") || // AWS S3
+        url.includes("X-Goog-") || // Google Cloud Storage
+        (url.includes("sig=") && url.includes("se=")); // Azure Blob Storage SAS
+    if (isPresignedUrl) {
+        const urlObj = new URL(url);
+        headers["host"] = urlObj.hostname; // Override to prevent :443 from being appended
+    }
     if (startOffset > 0) {
         headers["Range"] = `bytes=${startOffset}-`;
     }

package/dist/server/rpc/handlers/transcribe-stream.js

@@ -1,9 +1,13 @@
 import { transcribeStream } from "../../bare/addons/whispercpp/index.js";
 export async function* handleTranscribeStream(request) {
-    const { modelId, audioChunk } = request;
+    const { modelId, audioChunk, prompt } = request;
     try {
         // Stream transcription results in real-time
-        for await (const textChunk of transcribeStream({ audioChunk, modelId })) {
+        for await (const textChunk of transcribeStream({
+            audioChunk,
+            modelId,
+            prompt,
+        })) {
             yield {
                 type: "transcribeStream",
                 text: textChunk,

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

@@ -0,0 +1,13 @@
+import type { Tool, ToolCallEvent } from "../../schemas/index";
+interface HistoryMessage {
+    role: string;
+    content: string;
+    attachments?: {
+        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[];
+export {};
+//# sourceMappingURL=tool-integration.d.ts.map

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

@@ -0,0 +1,43 @@
+import { parseToolCalls, convertToolsToGrammar, } from "./tool-parser.js";
+export function insertToolsIntoHistory(history, tools) {
+    const systemMsgIndex = history.findIndex((msg) => msg.role === "system");
+    if (systemMsgIndex >= 0) {
+        return [
+            ...history.slice(0, systemMsgIndex + 1),
+            ...tools,
+            ...history.slice(systemMsgIndex + 1),
+        ];
+    }
+    return [...tools, ...history];
+}
+export function setupToolGrammar(modelConfig, tools) {
+    const grammar = convertToolsToGrammar(tools);
+    modelConfig["grammar"] = grammar;
+}
+export function checkForToolEvents(accumulatedText, currentToken, tools, emittedToolCallPositions) {
+    const 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;
+}

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

@@ -1,5 +1,14 @@
-function generateToolCallId() {
-    return `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+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") {
@@ -63,7 +72,7 @@ function parseGemmaFormat(text, tools) {
                     continue;
                 }
                 toolCalls.push({
-                    id: call.id || generateToolCallId(),
+                    id: call.id || generateStableToolCallId(call.name, call.arguments),
                     name: call.name,
                     arguments: call.arguments,
                     raw: JSON.stringify(call),
@@ -80,13 +89,14 @@ function parseQwenFormat(text, tools) {
     const toolCalls = [];
     const errors = [];
     const toolCallRegex = /<tool_call>\s*({[\s\S]*?})\s*<\/tool_call>/g;
-    let match;
-    while ((match = toolCallRegex.exec(text)) !== null) {
+    const matches = Array.from(text.matchAll(toolCallRegex));
+    for (const match of matches) {
         try {
             const callJson = match[1];
             if (!callJson)
                 continue;
-            const callItem = JSON.parse(callJson);
+            const trimmedJson = callJson.trim();
+            const callItem = JSON.parse(trimmedJson);
             if (!isValidToolCall(callItem)) {
                 continue;
             }
@@ -95,15 +105,15 @@ function parseQwenFormat(text, tools) {
             if (!validation.isValid && validation.error) {
                 errors.push({
                     ...validation.error,
-                    raw: callJson,
+                    raw: trimmedJson,
                 });
                 continue;
             }
             toolCalls.push({
-                id: call.id || generateToolCallId(),
+                id: call.id || generateStableToolCallId(call.name, call.arguments),
                 name: call.name,
                 arguments: call.arguments,
-                raw: callJson,
+                raw: trimmedJson,
             });
         }
         catch (error) {
@@ -132,7 +142,8 @@ function parseLlamacppFormat(text, tools) {
             }
             else {
                 toolCalls.push({
-                    id: parsed.id || generateToolCallId(),
+                    id: parsed.id ||
+                        generateStableToolCallId(parsed.name, parsed.arguments),
                     name: parsed.name,
                     arguments: parsed.arguments,
                     raw: text,
@@ -164,7 +175,7 @@ function parseGenericFormat(text, tools) {
                     continue;
                 }
                 toolCalls.push({
-                    id: obj.id || generateToolCallId(),
+                    id: obj.id || generateStableToolCallId(obj.name, obj.arguments),
                     name: obj.name,
                     arguments: obj.arguments,
                     raw: match[0],
@@ -186,17 +197,20 @@ export function parseToolCalls(text, tools) {
         return { toolCalls: [], errors: [] };
     }
     let result = parseGemmaFormat(text, tools);
-    if (result.toolCalls.length > 0 || result.errors.length > 0) {
+    if (result.toolCalls.length > 0) {
         return result;
     }
     result = parseQwenFormat(text, tools);
-    if (result.toolCalls.length > 0 || result.errors.length > 0) {
+    if (result.toolCalls.length > 0) {
         return result;
     }
     result = parseLlamacppFormat(text, tools);
-    if (result.toolCalls.length > 0 || result.errors.length > 0) {
+    if (result.toolCalls.length > 0) {
         return result;
     }
+    if (text.includes("<tool_call>")) {
+        return { toolCalls: [], errors: [] };
+    }
     result = parseGenericFormat(text, tools);
     return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -60,7 +60,7 @@
     "@qvac/langdetect-text": "^0.1.0",
     "@qvac/logging": "^0.1.0",
     "@qvac/rag": "^0.2.1",
-    "@qvac/transcription-whispercpp": "^0.1.8",
+    "@qvac/transcription-whispercpp": "^0.1.14",
     "@qvac/translation-nmtcpp": "^0.1.2",
     "@qvac/tts-onnx": "^0.2.1",
     "fast-safe-stringify": "2.1.1",