@qvac/sdk 0.2.7-dev.1761566029.f834aa3 → 0.4.0

package/dist/schemas/translation-config.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 // Marian model languages
-const MARIAN_LANGUAGES = ["en", "de", "es", "it"];
+const MARIAN_LANGUAGES = ["en", "de", "es", "it", "ru", "ja"];
 // IndicTrans2 model languages
 export const INDICTRANS_LANGUAGES = [
     "asm_Beng", // Assamese
@@ -39,8 +39,25 @@ export const nmtConfigSchema = z
     mode: z.enum(["full"]).optional(),
     from: z.enum(NMT_LANGUAGES),
     to: z.enum(NMT_LANGUAGES),
+    // Generation parameters (lowercase to match addon expectations)
+    beamsize: z.number().optional(),
+    lengthpenalty: z.number().optional(),
+    maxlength: z.number().optional(),
+    repetitionpenalty: z.number().optional(),
+    norepeatngramsize: z.number().optional(),
+    temperature: z.number().optional(),
+    topk: z.number().optional(),
+    topp: z.number().optional(),
 })
     .transform((data) => ({
     ...data,
     mode: data.mode ?? "full",
+    beamsize: data.beamsize ?? 4,
+    lengthpenalty: data.lengthpenalty ?? 1.0,
+    maxlength: data.maxlength ?? 512,
+    repetitionpenalty: data.repetitionpenalty ?? 1.0,
+    norepeatngramsize: data.norepeatngramsize ?? 0,
+    temperature: data.temperature ?? 0.3,
+    topk: data.topk ?? 0,
+    topp: data.topp ?? 1.0,
 }));

package/dist/schemas/unload-model.d.ts

@@ -12,6 +12,8 @@ export declare const unloadModelResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"unloadModel">;
     success: z.ZodBoolean;
     error: z.ZodOptional<z.ZodString>;
+    hasActiveModels: z.ZodOptional<z.ZodBoolean>;
+    hasActiveProviders: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type UnloadModelParams = z.input<typeof unloadModelParamsSchema>;
 export type UnloadModelRequest = z.infer<typeof unloadModelRequestSchema>;

package/dist/schemas/unload-model.js

@@ -10,4 +10,6 @@ export const unloadModelResponseSchema = z.object({
     type: z.literal("unloadModel"),
     success: z.boolean(),
     error: z.string().optional(),
+    hasActiveModels: z.boolean().optional(),
+    hasActiveProviders: z.boolean().optional(),
 });

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

@@ -1,24 +1,61 @@
 import { z } from "zod";
 export declare const whisperConfigSchema: z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<{
-        caption: "caption";
-        batch: "batch";
+    strategy: z.ZodOptional<z.ZodEnum<{
+        greedy: "greedy";
+        beam_search: "beam_search";
     }>>;
-    output_format: z.ZodDefault<z.ZodEnum<{
-        plaintext: "plaintext";
-        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>;
+    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>;
+    vad_model_path: 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>>;
+    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,66 @@
 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(),
+    vad_model_path: z.string().optional(),
+    vad_params: vadParamsSchema,
+    audio_format: z.string().optional(),
+    contextParams: contextParamsSchema,
+    miscConfig: miscConfigSchema,
 });

package/dist/server/bare/addons/cancel.js

@@ -1,10 +1,11 @@
 import { getModel } from "../registry/model-registry.js";
 import { cancelInferenceBaseSchema, } from "../../../schemas/index.js";
+import { ModelNotLoadedError } from "../../../utils/errors-server.js";
 export async function cancel(params) {
     const { modelId } = cancelInferenceBaseSchema.parse(params);
     const model = getModel(modelId);
     if (!model) {
-        throw new Error(`Model with ID "${modelId}" is not loaded`);
+        throw new ModelNotLoadedError(modelId);
     }
     if (model.addon && model.addon.cancel) {
         await model.addon.cancel();

package/dist/server/bare/addons/llamacpp/create-model.d.ts

@@ -1,5 +1,12 @@
 import type { AnyModel } from "../../registry/model-registry";
 import type { EmbedConfig, LlmConfig } from "../../../../schemas/index";
-export declare function createLlmModel(modelId: string, modelPath: string, llmConfig: LlmConfig, projectionModelPath?: string): AnyModel;
-export declare function createEmbeddingsModel(modelId: string, modelPath: string, embedConfig: EmbedConfig): AnyModel;
+import FilesystemDL from "@qvac/dl-filesystem";
+export declare function createLlmModel(modelId: string, modelPath: string, llmConfig: LlmConfig, projectionModelPath?: string): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
+export declare function createEmbeddingsModel(modelId: string, modelPath: string, embedConfig: EmbedConfig): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
 //# sourceMappingURL=create-model.d.ts.map

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

@@ -1,34 +1,32 @@
 import LlmLlamacpp from "@qvac/llm-llamacpp";
 import EmbedLlamacpp from "@qvac/embed-llamacpp";
-import { Readable } from "bare-stream";
 import { createStreamLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
-// Mimic qvac-lib-dl-filesystem functionality
-function createFilesystemDLMimic() {
-    return {
-        dirPath: "./",
-        getStream: () => Promise.resolve(Readable.from([])),
-        ready: () => Promise.resolve(),
-        close: () => Promise.resolve(),
-        destroy: () => Promise.resolve(),
-        start: () => Promise.resolve(),
-        stop: () => Promise.resolve(),
-    };
-}
+import FilesystemDL from "@qvac/dl-filesystem";
 function transformLlmConfig(llmConfig) {
-    return JSON.parse(JSON.stringify(llmConfig, (key, v) => key === "modelType"
+    const transformed = JSON.parse(JSON.stringify(llmConfig, (key, v) => key === "modelType"
         ? undefined
-        : typeof v === "number" || typeof v === "boolean"
-            ? String(v)
-            : v).replace(/"([a-z][A-Za-z]*)":/g, (_, key) => `"${key.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`)}":`));
+        : key === "stop_sequences"
+            ? Array.isArray(v)
+                ? v.join(", ")
+                : v
+            : typeof v === "number" || typeof v === "boolean"
+                ? String(v)
+                : v).replace(/"([a-z][A-Za-z]*)":/g, (_, key) => `"${key.replace(/[A-Z]/g, (l) => `_${l.toLowerCase()}`)}":`));
+    // Rename stop_sequences to reverse_prompt for the addon
+    if ("stop_sequences" in transformed) {
+        transformed["reverse_prompt"] = transformed["stop_sequences"];
+        delete transformed["stop_sequences"];
+    }
+    return transformed;
 }
 export function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    const dl = createFilesystemDLMimic();
+    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "llamacpp:llm");
     const llmConfigStrings = transformLlmConfig(llmConfig);
     const args = {
-        loader: dl,
+        loader,
         opts: { stats: true },
         logger,
         diskPath: dirPath,
@@ -39,19 +37,21 @@ export function createLlmModel(modelId, modelPath, llmConfig, projectionModelPat
         modelPath,
         modelConfig: llmConfigStrings,
     };
-    return new LlmLlamacpp(args, llmConfigStrings);
+    const model = new LlmLlamacpp(args, llmConfigStrings);
+    return { model, loader };
 }
 export function createEmbeddingsModel(modelId, modelPath, embedConfig) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    const dl = createFilesystemDLMimic();
+    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "llamacpp:embed");
     const args = {
-        loader: dl,
+        loader,
         opts: { stats: true },
         logger,
         diskPath: dirPath,
         modelName: basePath,
         modelPath,
     };
-    return new EmbedLlamacpp(args, embedConfig.config);
+    const model = new EmbedLlamacpp(args, embedConfig.config);
+    return { model, loader };
 }

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

@@ -1,3 +1,11 @@
-import { type CompletionStats, type CompletionParams } from "../../../../../schemas/index";
-export declare function completion(params: CompletionParams): AsyncGenerator<string, CompletionStats, unknown>;
+import { type CompletionParams, type CompletionStats, type Tool, type ToolCall, type ToolCallEvent } from "../../../../../schemas/index";
+export declare function completion(params: CompletionParams & {
+    tools?: Tool[];
+}): AsyncGenerator<{
+    token: string;
+    toolCallEvent?: ToolCallEvent;
+}, {
+    stats: CompletionStats;
+    toolCalls: ToolCall[];
+}, unknown>;
 //# sourceMappingURL=completion-stream.d.ts.map

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

@@ -1,20 +1,38 @@
-import { completionParamsSchema, } from "../../../../../schemas/index.js";
+import {} from "../../../../../schemas/index.js";
+import { customCacheExists, extractSystemPrompt, findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, renameCacheFile, } from "../kv-cache-utils.js";
 import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
-import { findMatchingCache, getCurrentCacheInfo, renameCacheFile, getCacheFilePath, extractSystemPrompt, generateConfigHash, customCacheExists, } from "../kv-cache-utils";
+import { checkForToolEvents, insertToolsIntoHistory, setupToolGrammar, } from "../../../../utils/tool-integration.js";
+import { parseToolCalls } from "../../../../utils/tool-parser.js";
+import { AttachmentNotFoundError } from "../../../../../utils/errors-server.js";
+import fs from "bare-fs";
 function transformMessage(message) {
     const transformed = [];
-    if (message.attachments && message.attachments.length > 0) {
-        for (const attachment of message.attachments) {
+    // Check if it's a tool definition (has type: "function")
+    if ("type" in message && message.type === "function") {
+        transformed.push({
+            type: "function",
+            name: message.name,
+            description: message.description,
+            parameters: message.parameters,
+        });
+        return transformed;
+    }
+    const msg = message;
+    if (msg.attachments && msg.attachments.length > 0) {
+        for (const attachment of msg.attachments) {
+            if (!fs.existsSync(attachment.path)) {
+                throw new AttachmentNotFoundError(attachment.path);
+            }
             transformed.push({
-                role: message.role,
+                role: msg.role,
                 content: attachment.path,
                 type: "media",
             });
         }
     }
     transformed.push({
-        role: message.role,
-        content: message.content,
+        role: msg.role,
+        content: msg.content,
     });
     return transformed;
 }
@@ -25,11 +43,15 @@ function transformMessages(messages) {
     }
     return transformed;
 }
-async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse) {
+async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools) {
     const primeMessages = [
         { role: "session", content: cachePathToUse },
         { role: "system", content: systemPromptToUse },
     ];
+    if (tools && tools.length > 0) {
+        const transformedTools = transformMessages(tools);
+        primeMessages.push(...transformedTools);
+    }
     const primeResponse = await model.run(primeMessages);
     primeResponse.once("output", () => {
         void primeResponse.cancel();
@@ -52,55 +74,52 @@ function prepareMessagesForCache(cachePathToUse, cacheExists, history) {
         ...transformedHistoryWithoutSystem,
     ];
 }
-async function* processModelResponse(model, messagesToSend, shouldSaveCache) {
+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;
-    });
-    response.onError((error) => {
-        if (rejectOnError) {
-            rejectOnError(error);
-        }
-    });
-    const iterator = response.iterate();
-    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;
+    let accumulatedText = "";
+    const emittedToolCallPositions = new Set();
+    let toolCallsResult = [];
+    for await (const token of response.iterate()) {
+        const tokenStr = token;
+        accumulatedText += tokenStr;
+        yield { token: tokenStr };
+        if (tools && tools.length > 0) {
+            const toolEvents = checkForToolEvents(accumulatedText, tokenStr, tools, emittedToolCallPositions);
+            for (const toolEvent of toolEvents) {
+                yield { token: "", toolCallEvent: toolEvent };
             }
-            yield result.value;
         }
     }
-    catch (error) {
-        if (error instanceof Error) {
-            throw error;
-        }
-        else {
-            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" }]);
     }
     const responseWithStats = response;
-    return {
+    const stats = {
         timeToFirstToken: responseWithStats.stats?.TTFT ?? 0,
         tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
         cacheTokens: responseWithStats.stats?.CacheTokens ?? 0,
     };
+    return { stats, toolCalls: toolCallsResult };
 }
 export async function* completion(params) {
-    const { history, modelId, kvCache } = completionParamsSchema.parse(params);
-    const transformedHistory = transformMessages(history);
+    const { history, modelId, kvCache, tools } = params;
+    const modelConfig = getModelConfig(modelId);
+    const toolsEnabled = modelConfig.tools === true;
+    let historyWithTools = history;
+    if (tools && tools.length > 0 && toolsEnabled) {
+        historyWithTools = insertToolsIntoHistory(history, tools);
+        setupToolGrammar(modelConfig, tools);
+    }
+    const transformedHistory = transformMessages(historyWithTools);
     const model = getModel(modelId);
     if (kvCache) {
         const modelConfig = getModelConfig(modelId);
         const systemPromptFromHistory = extractSystemPrompt(history);
-        const configHash = generateConfigHash(modelConfig, systemPromptFromHistory);
+        const configHash = generateConfigHash(modelConfig, systemPromptFromHistory, tools);
         const systemPromptToUse = systemPromptFromHistory ||
             modelConfig.system_prompt ||
             "You are a helpful assistant.";
@@ -109,10 +128,10 @@ export async function* completion(params) {
             cachePathToUse = await getCacheFilePath(modelId, configHash, kvCache);
             const cacheExists = await customCacheExists(modelId, configHash, kvCache);
             if (!cacheExists) {
-                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse);
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools && toolsEnabled ? tools : undefined);
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
-            return yield* processModelResponse(model, messagesToSend, true);
+            return yield* processModelResponse(model, messagesToSend, true, tools);
         }
         else {
             // Auto-generate cache key based on conversation history
@@ -129,10 +148,10 @@ export async function* completion(params) {
                     : currentCacheInfo.cachePath;
             const cacheExists = existingCache !== null;
             if (!cacheExists) {
-                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse);
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools && toolsEnabled ? tools : undefined);
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
-            const result = yield* processModelResponse(model, messagesToSend, true);
+            const result = yield* processModelResponse(model, messagesToSend, true, tools);
             //If there was an existing cache, we rename it with new hash that includes the current message
             if (existingCache !== null &&
                 existingCache.cachePath !== currentCacheInfo.cachePath) {
@@ -142,6 +161,6 @@ export async function* completion(params) {
         }
     }
     else {
-        return yield* processModelResponse(model, transformedHistory, false);
+        return yield* processModelResponse(model, transformedHistory, false, tools);
     }
 }

package/dist/server/bare/addons/llamacpp/handlers/embed.js

@@ -1,5 +1,6 @@
 import { getModel } from "../../../registry/model-registry.js";
 import { embedParamsSchema } from "../../../../../schemas/index.js";
+import { EmbedNoEmbeddingsError, EmbedFailedError, } from "../../../../../utils/errors-server.js";
 export async function embed(params) {
     const { modelId, text } = embedParamsSchema.parse(params);
     const model = getModel(modelId);
@@ -7,7 +8,7 @@ export async function embed(params) {
     const rawEmbeddings = (await response.await());
     const embeddingVector = rawEmbeddings?.[0]?.[0];
     if (!embeddingVector || embeddingVector.length === 0) {
-        throw new Error("No embeddings returned");
+        throw new EmbedNoEmbeddingsError();
     }
     return normalizeVector(embeddingVector);
 }
@@ -16,7 +17,7 @@ export function normalizeVector(vector) {
     for (let i = 0; i < vector.length; i++) {
         const value = vector[i];
         if (!Number.isFinite(value)) {
-            throw new Error(`NormalizeVector: non-finite value at index ${i}: ${value}`);
+            throw new EmbedFailedError(`NormalizeVector: non-finite value at index ${i}: ${value}`);
         }
         sumOfSquares += value * value;
     }

package/dist/server/bare/addons/llamacpp/kv-cache-utils.d.ts

@@ -6,7 +6,7 @@ export interface CacheMessage {
     }[] | undefined;
 }
 export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
-export declare function generateConfigHash(modelConfig: unknown, systemPrompt: string | null): string;
+export declare function generateConfigHash(modelConfig: unknown, systemPrompt: string | null, tools?: unknown): string;
 export declare function generateCacheKey(messages: CacheMessage[]): string;
 export declare function getCacheFilePath(modelId: string, configHash: string, cacheKey: string): Promise<string>;
 export declare function findMatchingCache(modelId: string, configHash: string, currentHistory: CacheMessage[]): Promise<{

package/dist/server/bare/addons/llamacpp/kv-cache-utils.js

@@ -6,9 +6,13 @@ export function extractSystemPrompt(messages) {
     const systemMessage = messages.find((msg) => msg.role === "system");
     return systemMessage ? systemMessage.content : null;
 }
-export function generateConfigHash(modelConfig, systemPrompt) {
+export function generateConfigHash(modelConfig, systemPrompt, tools) {
     const hash = crypto.createHash("sha256");
-    const configStr = JSON.stringify({ config: modelConfig, systemPrompt });
+    const configStr = JSON.stringify({
+        config: modelConfig,
+        systemPrompt,
+        tools,
+    });
     const configBuffer = Buffer.from(configStr, "utf8");
     hash.update(configBuffer);
     const hashString = hash.digest("hex");