@qvac/sdk 0.8.1 → 1.0.0

package/dist/schemas/translation-config.js

@@ -1,35 +1,6 @@
 import { z } from "zod";
-import { modelSrcInputSchema } from "./model-src-utils.js";
-// Marian/Opus model languages
-export const MARIAN_LANGUAGES = ["en", "de", "es", "it", "ru", "ja"];
-// Bergamot supports many more language pairs
-export const BERGAMOT_LANGUAGES = [
-    "en",
-    "ar",
-    "bg",
-    "ca",
-    "cs",
-    "de",
-    "es",
-    "et",
-    "fi",
-    "fr",
-    "hu",
-    "is",
-    "it",
-    "ja",
-    "ko",
-    "lt",
-    "lv",
-    "nl",
-    "pl",
-    "pt",
-    "ru",
-    "sk",
-    "sl",
-    "uk",
-    "zh",
-];
+// Marian model languages
+const MARIAN_LANGUAGES = ["en", "de", "es", "it", "ru", "ja"];
 // IndicTrans2 model languages
 export const INDICTRANS_LANGUAGES = [
     "asm_Beng", // Assamese
@@ -59,94 +30,17 @@ export const INDICTRANS_LANGUAGES = [
     "tel_Telu", // Telugu
     "urd_Arab", // Urdu
 ];
-export const AFRICAN_LANGUAGES_MAP = new Map([
-    ["afr_Latn", "Afrikaans"],
-    ["swh_Latn", "Swahili"],
-    ["ary_Arab", "Moroccan Arabic"],
-    ["som_Latn", "Somali"],
-    ["amh_Ethi", "Amharic"],
-    ["arz_Arab", "Egyptian Arabic"],
-    ["hau_Latn", "Hausa"],
-    ["kin_Latn", "Kinyarwanda"],
-    ["zul_Latn", "Zulu"],
-    ["ibo_Latn", "Igbo"],
-    ["plt_Latn", "Plateau Malagasy"],
-    ["xho_Latn", "Xhosa"],
-    ["sna_Latn", "Shona"],
-    ["yor_Latn", "Yoruba"],
-    ["nya_Latn", "Nyanja"],
-    ["sot_Latn", "Southern Sotho"],
-    ["tir_Ethi", "Tigrinya"],
-    ["aeb_Arab", "Tunisian Arabic"],
-    ["gaz_Latn", "Oromo"],
-    ["tsn_Latn", "Tswana"],
-]);
-// Union of all NMT languages (for general type usage)
 export const NMT_LANGUAGES = [
     ...MARIAN_LANGUAGES,
-    ...BERGAMOT_LANGUAGES,
     ...INDICTRANS_LANGUAGES,
 ];
-export const NMT_ENGINES = ["Opus", "Bergamot", "IndicTrans"];
-// Common generation parameters (without language fields)
-const nmtGenerationParamsSchema = z.object({
+export const nmtConfigSchema = z
+    .object({
     mode: z.enum(["full"]).optional(),
-    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(),
-});
-// Opus engine config (Marian-based) - supports MARIAN_LANGUAGES
-const opusConfigSchema = nmtGenerationParamsSchema.extend({
-    engine: z.literal("Opus"),
-    from: z.enum(MARIAN_LANGUAGES),
-    to: z.enum(MARIAN_LANGUAGES),
-});
-// Pivot model configuration for Bergamot (for translation via intermediate language)
-const bergamotPivotModelSchema = nmtGenerationParamsSchema
-    .extend({
-    modelSrc: modelSrcInputSchema,
-    srcVocabSrc: modelSrcInputSchema.optional(),
-    dstVocabSrc: modelSrcInputSchema.optional(),
-    normalize: z.number().optional(),
+    from: z.enum(NMT_LANGUAGES),
+    to: z.enum(NMT_LANGUAGES),
 })
-    .optional();
-// Bergamot engine config - supports BERGAMOT_LANGUAGES
-const bergamotConfigSchema = nmtGenerationParamsSchema.extend({
-    engine: z.literal("Bergamot"),
-    from: z.enum(BERGAMOT_LANGUAGES),
-    to: z.enum(BERGAMOT_LANGUAGES),
-    srcVocabSrc: modelSrcInputSchema.optional(),
-    dstVocabSrc: modelSrcInputSchema.optional(),
-    normalize: z.number().optional(),
-    pivotModel: bergamotPivotModelSchema,
-});
-// IndicTrans engine config - supports INDICTRANS_LANGUAGES
-const indicTransConfigSchema = nmtGenerationParamsSchema.extend({
-    engine: z.literal("IndicTrans"),
-    from: z.enum(INDICTRANS_LANGUAGES),
-    to: z.enum(INDICTRANS_LANGUAGES),
-});
-// Discriminated union of all engine configs
-export const nmtConfigBaseSchema = z.discriminatedUnion("engine", [
-    opusConfigSchema,
-    bergamotConfigSchema,
-    indicTransConfigSchema,
-]);
-// Apply defaults via transform
-export const nmtConfigSchema = nmtConfigBaseSchema.transform((data) => ({
+    .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,8 +12,6 @@ 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,6 +10,4 @@ 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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const whisperConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        caption: "caption";
+        batch: "batch";
+    }>>;
+    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>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WhisperConfig = z.infer<typeof whisperConfigSchema>;
+//# sourceMappingURL=whispercpp-config.d.ts.map

package/dist/schemas/whispercpp-config.js

@@ -0,0 +1,18 @@
+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(),
+});
+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(),
+});

package/dist/server/bare/{ops → addons}/cancel.js

@@ -1,11 +1,10 @@
 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 ModelNotLoadedError(modelId);
+        throw new Error(`Model with ID "${modelId}" is not loaded`);
     }
     if (model.addon && model.addon.cancel) {
         await model.addon.cancel();

package/dist/server/bare/addons/index.d.ts

@@ -0,0 +1,4 @@
+export { loadModel } from "./load-model";
+export { unloadModel } from "./unload-model";
+export { cancel } from "./cancel";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+export { loadModel } from "./load-model.js";
+export { unloadModel } from "./unload-model.js";
+export { cancel } from "./cancel.js";

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

@@ -0,0 +1,5 @@
+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;
+//# sourceMappingURL=create-model.d.ts.map

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

@@ -0,0 +1,67 @@
+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(),
+    };
+}
+function transformLlmConfig(llmConfig) {
+    const transformed = JSON.parse(JSON.stringify(llmConfig, (key, v) => key === "modelType"
+        ? undefined
+        : 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 logger = createStreamLogger(modelId, "llamacpp:llm");
+    const llmConfigStrings = transformLlmConfig(llmConfig);
+    const args = {
+        loader: dl,
+        opts: { stats: true },
+        logger,
+        diskPath: dirPath,
+        modelName: basePath,
+        projectionModel: projectionModelPath
+            ? parseModelPath(projectionModelPath).basePath
+            : "",
+        modelPath,
+        modelConfig: llmConfigStrings,
+    };
+    return new LlmLlamacpp(args, llmConfigStrings);
+}
+export function createEmbeddingsModel(modelId, modelPath, embedConfig) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const dl = createFilesystemDLMimic();
+    const logger = createStreamLogger(modelId, "llamacpp:embed");
+    const args = {
+        loader: dl,
+        opts: { stats: true },
+        logger,
+        diskPath: dirPath,
+        modelName: basePath,
+        modelPath,
+    };
+    return new EmbedLlamacpp(args, embedConfig.config);
+}

package/dist/server/bare/{plugins/llamacpp-completion/ops → addons/llamacpp/handlers}/completion-stream.d.ts

@@ -1,7 +1,6 @@
-import type { CompletionParams, CompletionStats, GenerationParams, Tool, ToolCall, ToolCallEvent } from "../../../../../schemas/index";
+import { type CompletionStats, type CompletionParams, type Tool, type ToolCall, type ToolCallEvent } from "../../../../../schemas/index";
 export declare function completion(params: CompletionParams & {
     tools?: Tool[];
-    generationParams?: GenerationParams;
 }): AsyncGenerator<{
     token: string;
     toolCallEvent?: ToolCallEvent;

package/dist/server/bare/{plugins/llamacpp-completion/ops → addons/llamacpp/handlers}/completion-stream.js

@@ -1,10 +1,8 @@
-import { logCacheDisabled, logCacheInit, logCacheSave, logCacheStatus, logMessagesToAddon, } from "./cache-logger.js";
-import { customCacheExists, extractSystemPrompt, findMatchingCache, generateConfigHash, getCacheFilePath, getCurrentCacheInfo, markCacheInitialized, renameCacheFile, } from "../../../ops/kv-cache-utils.js";
+import {} from "../../../../../schemas/index.js";
 import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
-import { checkForToolEvents, insertToolsIntoHistory, setupToolGrammar, } from "../../../../utils/tool-integration.js";
-import { parseToolCalls } from "../../../../utils/tool-parser.js";
-import { AttachmentNotFoundError } from "../../../../../utils/errors-server.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";
 function transformMessage(message) {
     const transformed = [];
     // Check if it's a tool definition (has type: "function")
@@ -21,7 +19,7 @@ function transformMessage(message) {
     if (msg.attachments && msg.attachments.length > 0) {
         for (const attachment of msg.attachments) {
             if (!fs.existsSync(attachment.path)) {
-                throw new AttachmentNotFoundError(attachment.path);
+                throw new Error(`Attachment not found at path: ${attachment.path}`);
             }
             transformed.push({
                 role: msg.role,
@@ -43,19 +41,15 @@ function transformMessages(messages) {
     }
     return transformed;
 }
-async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, cacheKey, tools) {
+async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools) {
     const primeMessages = [
         { role: "session", content: cachePathToUse },
         { role: "system", content: systemPromptToUse },
     ];
-    let toolCount = 0;
     if (tools && tools.length > 0) {
         const transformedTools = transformMessages(tools);
         primeMessages.push(...transformedTools);
-        toolCount = tools.length;
     }
-    logCacheInit(cacheKey, systemPromptToUse, toolCount);
-    logMessagesToAddon(primeMessages, "CACHE_INIT");
     const primeResponse = await model.run(primeMessages);
     primeResponse.once("output", () => {
         void primeResponse.cancel();
@@ -78,33 +72,68 @@ function prepareMessagesForCache(cachePathToUse, cacheExists, history) {
         ...transformedHistoryWithoutSystem,
     ];
 }
-async function* processModelResponse(model, messagesToSend, shouldSaveCache, tools, generationParams) {
-    const runFn = model.run.bind(model);
-    const runOptions = generationParams ? { generationParams } : undefined;
-    const response = await runFn(messagesToSend, runOptions);
+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();
     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 };
+    const emittedToolCalls = new Set();
+    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;
+            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;
+                    }
+                }
+            }
+            yield { token };
         }
     }
-    if (tools && tools.length > 0) {
-        const { toolCalls } = parseToolCalls(accumulatedText, tools);
-        toolCallsResult = toolCalls;
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        else {
+            throw new Error(String(error));
+        }
     }
     if (shouldSaveCache) {
-        const sessionMsg = messagesToSend.find((m) => m.role === "session");
-        if (sessionMsg?.content) {
-            logCacheSave(sessionMsg.content);
-        }
         await model.run([{ role: "session", content: "save" }]);
     }
     const responseWithStats = response;
@@ -113,39 +142,49 @@ async function* processModelResponse(model, messagesToSend, shouldSaveCache, too
         tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
         cacheTokens: responseWithStats.stats?.CacheTokens ?? 0,
     };
-    return { stats, toolCalls: toolCallsResult };
+    const { toolCalls } = parseToolCalls(accumulatedText, tools || []);
+    return { stats, toolCalls };
 }
 export async function* completion(params) {
-    const { history, modelId, kvCache, tools, generationParams } = 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) {
-        historyWithTools = insertToolsIntoHistory(history, tools);
-        setupToolGrammar(modelConfig, tools);
+        // 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;
     }
     const transformedHistory = transformMessages(historyWithTools);
     const model = getModel(modelId);
     if (kvCache) {
         const modelConfig = getModelConfig(modelId);
         const systemPromptFromHistory = extractSystemPrompt(history);
-        const configHash = generateConfigHash(systemPromptFromHistory, tools);
+        const configHash = generateConfigHash(modelConfig, systemPromptFromHistory, tools);
         const systemPromptToUse = systemPromptFromHistory ||
             modelConfig.system_prompt ||
             "You are a helpful assistant.";
         let cachePathToUse;
         if (typeof kvCache === "string") {
             cachePathToUse = await getCacheFilePath(modelId, configHash, kvCache);
-            let cacheExists = await customCacheExists(modelId, configHash, kvCache);
-            logCacheStatus(kvCache, cacheExists);
+            const cacheExists = await customCacheExists(modelId, configHash, kvCache);
             if (!cacheExists) {
-                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, kvCache, tools && toolsEnabled ? tools : undefined);
-                markCacheInitialized(modelId, configHash, kvCache);
-                cacheExists = true;
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools && toolsEnabled ? tools : undefined);
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
-            logMessagesToAddon(messagesToSend, "PROMPT_SEND");
-            return yield* processModelResponse(model, messagesToSend, true, tools, generationParams);
+            return yield* processModelResponse(model, messagesToSend, true, tools);
         }
         else {
             // Auto-generate cache key based on conversation history
@@ -160,16 +199,12 @@ export async function* completion(params) {
                 existingCache !== null
                     ? existingCache.cachePath
                     : currentCacheInfo.cachePath;
-            let cacheExists = existingCache !== null;
-            logCacheStatus("auto", cacheExists);
+            const cacheExists = existingCache !== null;
             if (!cacheExists) {
-                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, "auto", tools && toolsEnabled ? tools : undefined);
-                markCacheInitialized(modelId, configHash, currentCacheInfo.cacheKey);
-                cacheExists = true;
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse, tools && toolsEnabled ? tools : undefined);
             }
             const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
-            logMessagesToAddon(messagesToSend, "PROMPT_SEND");
-            const result = yield* processModelResponse(model, messagesToSend, true, tools, generationParams);
+            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) {
@@ -179,8 +214,6 @@ export async function* completion(params) {
         }
     }
     else {
-        logCacheDisabled();
-        logMessagesToAddon(transformedHistory, "NO_CACHE");
-        return yield* processModelResponse(model, transformedHistory, false, tools, generationParams);
+        return yield* processModelResponse(model, transformedHistory, false, tools);
     }
 }

package/dist/server/bare/addons/llamacpp/handlers/embed.d.ts

@@ -0,0 +1,4 @@
+import { type EmbedParams } from "../../../../../schemas/index";
+export declare function embed(params: EmbedParams): Promise<number[]>;
+export declare function normalizeVector(vector: Float32Array): number[];
+//# sourceMappingURL=embed.d.ts.map

package/dist/server/bare/{ops → addons/llamacpp/handlers}/embed.js

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

package/dist/server/bare/addons/llamacpp/index.d.ts

@@ -0,0 +1,4 @@
+export { completion } from "./handlers/completion-stream";
+export { embed } from "./handlers/embed";
+export { createLlmModel, createEmbeddingsModel } from "./create-model";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/addons/llamacpp/index.js

@@ -0,0 +1,3 @@
+export { completion } from "./handlers/completion-stream.js";
+export { embed } from "./handlers/embed.js";
+export { createLlmModel, createEmbeddingsModel } from "./create-model.js";

package/dist/server/bare/{ops → addons/llamacpp}/kv-cache-utils.d.ts

@@ -1,6 +1,3 @@
-export declare function markCacheInitialized(modelId: string, configHash: string, cacheKey: string): void;
-export declare function isCacheInitialized(modelId: string, configHash: string, cacheKey: string): boolean;
-export declare function clearCacheRegistry(cacheKey?: string): void;
 export interface CacheMessage {
     role: string;
     content: string;
@@ -9,7 +6,7 @@ export interface CacheMessage {
     }[] | undefined;
 }
 export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
-export declare function generateConfigHash(systemPrompt: string | null, tools?: unknown): 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<{