@qvac/sdk 0.9.2 → 0.10.0

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-state.js

@@ -0,0 +1,135 @@
+/**
+ * Pure state + decision helpers for kv-cache bookkeeping used by
+ * `completion-stream.ts`.
+ *
+ * This module intentionally has **no** `bare-*` imports so it can be
+ * exercised directly from unit tests running under `bun` without pulling
+ * in the Bare runtime (which is not available in that environment).
+ * The file-system-dependent pieces (e.g. `recordCacheSaveCount`) live in
+ * `completion-stream.ts` and consume the state exported here.
+ */
+/**
+ * Number of chat messages the kv-cache file on disk is known to cover, keyed
+ * by cache path. Written after a successful completion records a save, read
+ * by `prepareMessagesForCache` to slice the history on the next turn so a
+ * consumer can stage multiple messages between completions (e.g. an
+ * `[assistant, user]` recovery sequence) without resending the whole history.
+ *
+ * INVARIANT: an entry is only present if the corresponding kv-cache file is
+ * considered trustworthy. On any turn where the SDK cannot prove the saved
+ * count reflects the on-disk state (cancellation mid-decode, zero-token
+ * reply, cache file missing after a save attempt), the entry MUST be
+ * deleted; a stale entry causes the next turn to slice its history down to
+ * an empty payload and the model returns zero tokens.
+ *
+ * Mode notes:
+ *   - Static-mode turns are the only readers of this map. `clearStaleCount`
+ *     in `decideCachedHistorySlice` exists so a stale-but-non-zero entry
+ *     can be detected and dropped on the next read.
+ *   - Dynamic-mode turns do NOT consume this map — the addon trims tools
+ *     and the chain output from the kv-cache after each round, so the
+ *     SDK falls back to role-based dispatch in `prepareMessagesForCache`.
+ *     Writes still happen on dynamic-mode turns, but the recorded count
+ *     reflects the messages the SDK shipped, not the (possibly trimmed)
+ *     on-disk cache shape. The map is internally consistent within a
+ *     single mode; a `kvCache` key should not be reused across modes.
+ */
+export const cachedMessageCounts = new Map();
+/**
+ * Monotonic counter of cancel requests per model. `completion()` snapshots
+ * the value before running the model and compares afterward to decide
+ * whether the turn was cancelled mid-decode. A counter (not a boolean) is
+ * used deliberately: a cancel that lands near a turn boundary cannot bleed
+ * into the next turn because we always compare snapshots, not values.
+ */
+const modelCancelCounters = new Map();
+/**
+ * Clear bookkeeping entries. With no argument, clears the whole map. With a
+ * `prefix`, removes any entry whose path is equal to it OR sits beneath it
+ * as a directory (i.e. `key.startsWith(prefix + sep)`).
+ *
+ * Runtime callers MUST pass the platform path separator (e.g. `path.sep`
+ * from `bare-path`) so directory-prefix matches are correct on every
+ * target. The "/" default exists only for unit tests under `bun`, where
+ * cache paths are POSIX-shaped and importing `bare-path` would pull in
+ * the Bare runtime. The exported wrapper in `completion-stream.ts`
+ * injects the real separator for in-process use.
+ */
+export function clearCachedMessageCounts(prefix, sep = "/") {
+    if (!prefix) {
+        cachedMessageCounts.clear();
+        return;
+    }
+    for (const key of cachedMessageCounts.keys()) {
+        if (key === prefix) {
+            cachedMessageCounts.delete(key);
+            continue;
+        }
+        if (!key.startsWith(prefix + sep))
+            continue;
+        cachedMessageCounts.delete(key);
+    }
+}
+/**
+ * Called from `server/bare/ops/cancel.ts` right before `addon.cancel()` so
+ * that the in-flight `completion()` for this model can detect that its
+ * current turn is being cancelled and skip poisoning `cachedMessageCounts`
+ * with a `history.length + 1` entry that does not correspond to a real
+ * assistant reply.
+ */
+export function noteCancelRequested(modelId) {
+    modelCancelCounters.set(modelId, (modelCancelCounters.get(modelId) ?? 0) + 1);
+}
+export function snapshotCancelCount(modelId) {
+    return modelCancelCounters.get(modelId) ?? 0;
+}
+/** Test-only. */
+export function _resetCancelCountersForTest() {
+    modelCancelCounters.clear();
+}
+/**
+ * A completion's `savedCount` should only be recorded when the turn ran to
+ * completion AND produced at least one token. Any other outcome —
+ * cancelled mid-decode, legitimate zero-token reply, or an early EOS — must
+ * clear the entry instead, because there is no guarantee that the kv-cache
+ * file on disk matches the `history.length + 1` boundary the SDK would
+ * otherwise record.
+ */
+export function shouldRecordSavedCount(wasCancelled, producedTokens) {
+    return !wasCancelled && producedTokens;
+}
+/**
+ * Pure slice decision for `prepareMessagesForCache`.
+ *
+ * Mirrors the shape of the logic in `completion-stream.ts` but without
+ * calling `transformMessages` (which depends on `bare-fs` for attachment
+ * probing). Kept here so the decision can be unit-tested in isolation.
+ *
+ * The key regression guard: when a non-zero `savedCount` would slice the
+ * history down to an empty array, it is treated as stale — the caller
+ * falls back to sending the system-stripped full history rather than
+ * handing the model an empty payload.
+ */
+export function decideCachedHistorySlice(savedCount, cacheExists, history) {
+    if (!cacheExists || history.length === 0) {
+        return {
+            messages: history.filter((msg) => msg.role !== "system"),
+            clearStaleCount: false,
+        };
+    }
+    const canSlice = savedCount > 0 && savedCount <= history.length;
+    const sliced = canSlice ? history.slice(savedCount) : null;
+    // A non-null slice that is empty means the saved count is stale: the
+    // cached turn boundary is claiming the entire current history is
+    // already cached, which happens when a previous turn was cancelled
+    // mid-decode and still recorded `history.length + 1`. Treat it as a
+    // bad state and resend the full (system-stripped) history.
+    const useSlice = sliced !== null && sliced.length > 0;
+    const messages = useSlice
+        ? sliced
+        : history.filter((msg) => msg.role !== "system");
+    return {
+        messages,
+        clearStaleCount: !useSlice && savedCount > 0,
+    };
+}

package/dist/server/bare/plugins/llamacpp-completion/plugin.d.ts

@@ -22,6 +22,10 @@ export declare const llmPlugin: {
         stop_sequences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
         n_discarded: import("zod").ZodOptional<import("zod").ZodNumber>;
         tools: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        toolsMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            static: "static";
+            dynamic: "dynamic";
+        }>>;
         "cache-type-k": import("zod").ZodOptional<import("zod").ZodString>;
         "cache-type-v": import("zod").ZodOptional<import("zod").ZodString>;
         openclCacheDir: import("zod").ZodOptional<import("zod").ZodString>;
@@ -37,6 +41,7 @@ export declare const llmPlugin: {
             expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                embeddings: "embeddings";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -47,7 +52,6 @@ export declare const llmPlugin: {
                 "sdcpp-generation": "sdcpp-generation";
                 llm: "llm";
                 whisper: "whisper";
-                embeddings: "embeddings";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 tts: "tts";
@@ -76,6 +80,7 @@ export declare const llmPlugin: {
             stop_sequences?: string[] | undefined;
             n_discarded?: number | undefined;
             tools?: boolean | undefined;
+            toolsMode?: "static" | "dynamic" | undefined;
             "cache-type-k"?: string | undefined;
             "cache-type-v"?: string | undefined;
             openclCacheDir?: string | undefined;
@@ -101,6 +106,7 @@ export declare const llmPlugin: {
             stop_sequences?: string[] | undefined;
             n_discarded?: number | undefined;
             tools?: boolean | undefined;
+            toolsMode?: "static" | "dynamic" | undefined;
             "cache-type-k"?: string | undefined;
             "cache-type-v"?: string | undefined;
             openclCacheDir?: string | undefined;
@@ -153,22 +159,45 @@ export declare const llmPlugin: {
                 presence_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
                 repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strict>>;
+            captureThinking: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            emitRawDeltas: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            toolDialect: import("zod").ZodOptional<import("zod").ZodEnum<{
+                hermes: "hermes";
+                pythonic: "pythonic";
+                json: "json";
+            }>>;
+            responseFormat: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"json_object">;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"json_schema">;
+                json_schema: import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    schema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+                    strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strict>], "type">>;
             type: import("zod").ZodLiteral<"completionStream">;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"completionStream">;
-            token: import("zod").ZodString;
             done: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                timeToFirstToken: import("zod").ZodOptional<import("zod").ZodNumber>;
-                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
-                cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    cpu: "cpu";
-                    gpu: "gpu";
-                }>>;
-            }, import("zod/v4/core").$strip>>;
-            toolCallEvent: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            events: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"contentDelta">;
+                seq: import("zod").ZodNumber;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"rawDelta">;
+                seq: import("zod").ZodNumber;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"thinkingDelta">;
+                seq: import("zod").ZodNumber;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"toolCall">;
+                seq: import("zod").ZodNumber;
                 call: import("zod").ZodObject<{
                     id: import("zod").ZodString;
                     name: import("zod").ZodString;
@@ -176,7 +205,8 @@ export declare const llmPlugin: {
                     raw: import("zod").ZodOptional<import("zod").ZodString>;
                 }, import("zod/v4/core").$strip>;
             }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"toolCallError">;
+                type: import("zod").ZodLiteral<"toolError">;
+                seq: import("zod").ZodNumber;
                 error: import("zod").ZodObject<{
                     code: import("zod").ZodEnum<{
                         PARSE_ERROR: "PARSE_ERROR";
@@ -186,15 +216,42 @@ export declare const llmPlugin: {
                     message: import("zod").ZodString;
                     raw: import("zod").ZodOptional<import("zod").ZodString>;
                 }, import("zod/v4/core").$strip>;
-            }, import("zod/v4/core").$strip>]>>;
-            toolCalls: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                name: import("zod").ZodString;
-                arguments: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
-                raw: import("zod").ZodOptional<import("zod").ZodString>;
-            }, import("zod/v4/core").$strip>>>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"completionStats">;
+                seq: import("zod").ZodNumber;
+                stats: import("zod").ZodObject<{
+                    timeToFirstToken: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    cacheTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    generatedTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        cpu: "cpu";
+                        gpu: "gpu";
+                    }>>;
+                }, import("zod/v4/core").$strip>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"completionDone">;
+                seq: import("zod").ZodNumber;
+                stopReason: import("zod").ZodLiteral<"error">;
+                error: import("zod").ZodObject<{
+                    message: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+                raw: import("zod").ZodOptional<import("zod").ZodObject<{
+                    fullText: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"completionDone">;
+                seq: import("zod").ZodNumber;
+                stopReason: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    eos: "eos";
+                    length: "length";
+                    stopSequence: "stopSequence";
+                }>>;
+                raw: import("zod").ZodOptional<import("zod").ZodObject<{
+                    fullText: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strict>]>>;
+        }, import("zod/v4/core").$strict>>;
         finetune: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
             modelId: import("zod").ZodString;
             options: import("zod").ZodObject<{

package/dist/server/bare/plugins/llamacpp-completion/plugin.js

@@ -1,14 +1,15 @@
-import LlmLlamacpp, {} from "@qvac/llm-llamacpp";
+import LlmLlamacpp from "@qvac/llm-llamacpp";
 import llmAddonLogging from "@qvac/llm-llamacpp/addonLogging.js";
-import { definePlugin, defineHandler, finetuneRequestSchema, completionStreamRequestSchema, completionStreamResponseSchema, finetuneResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, llmConfigBaseSchema, ADDON_LLM, } from "../../../../schemas/index.js";
+import { definePlugin, defineHandler, finetuneRequestSchema, completionStreamRequestSchema, completionStreamResponseSchema, finetuneResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, llmConfigBaseSchema, ADDON_LLM, TOOLS_MODE, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { parseModelPath } from "../../../utils/index.js";
-import FilesystemDL from "@qvac/dl-filesystem";
-import { asLoader } from "../../utils/loader-adapter.js";
+import { expandGGUFIntoShards } from "../../../utils/index.js";
 import { completion } from "./ops/completion-stream.js";
 import { finetune } from "./ops/finetune.js";
 import { translate } from "../../ops/translate.js";
 import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
+import { getModelConfig } from "../../registry/model-registry.js";
+import { createCompletionNormalizer } from "../../../utils/completion-normalizer.js";
+import { detectToolDialect } from "../../../utils/tool-integration.js";
 function transformLlmConfig(llmConfig) {
     const transformed = JSON.parse(JSON.stringify(llmConfig, (key, v) => key === "modelType"
         ? undefined
@@ -27,28 +28,29 @@ function transformLlmConfig(llmConfig) {
         transformed["openclCacheDir"] = transformed["opencl_cache_dir"];
         delete transformed["opencl_cache_dir"];
     }
+    if ("tools_mode" in transformed) {
+        if (transformed["tools_mode"] === TOOLS_MODE.dynamic) {
+            transformed["tools_compact"] = "true";
+        }
+        delete transformed["tools_mode"];
+    }
     return transformed;
 }
 function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
-    const { dirPath, basePath } = parseModelPath(modelPath);
-    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, ModelType.llamacppCompletion);
     registerAddonLogger(modelId, ModelType.llamacppCompletion, logger);
     const llmConfigStrings = transformLlmConfig(llmConfig);
-    const args = {
-        loader: asLoader(loader),
-        opts: { stats: true },
+    const modelFiles = expandGGUFIntoShards(modelPath);
+    const model = new LlmLlamacpp({
+        files: {
+            model: modelFiles,
+            ...(projectionModelPath && { projectionModel: projectionModelPath }),
+        },
+        config: llmConfigStrings,
         logger,
-        diskPath: dirPath,
-        modelName: basePath,
-        projectionModel: projectionModelPath
-            ? parseModelPath(projectionModelPath).basePath
-            : "",
-        modelPath,
-        modelConfig: llmConfigStrings,
-    };
-    const model = new LlmLlamacpp(args, llmConfigStrings);
-    return { model, loader };
+        opts: { stats: true },
+    });
+    return { model };
 }
 export const llmPlugin = definePlugin({
     modelType: ModelType.llamacppCompletion,
@@ -68,8 +70,8 @@ export const llmPlugin = definePlugin({
     },
     createModel(params) {
         const llmConfig = (params.modelConfig ?? {});
-        const { model, loader } = createLlmModel(params.modelId, params.modelPath, llmConfig, params.artifacts?.["projectionModelPath"]);
-        return { model, loader };
+        const { model } = createLlmModel(params.modelId, params.modelPath, llmConfig, params.artifacts?.["projectionModelPath"]);
+        return { model };
     },
     handlers: {
         completionStream: defineHandler({
@@ -82,38 +84,61 @@ export const llmPlugin = definePlugin({
                     content,
                     attachments: attachments ?? [],
                 }));
+                const modelCfg = getModelConfig(request.modelId);
+                const toolsActive = (request.tools?.length ?? 0) > 0 &&
+                    modelCfg.tools === true;
+                const capabilities = {
+                    toolCalling: toolsActive ? "textParse" : "none",
+                    thinkingFraming: request.captureThinking ? "thinkTags" : "none",
+                };
+                const dialect = toolsActive
+                    ? (request.toolDialect ?? detectToolDialect(request.modelId))
+                    : "hermes";
+                const normalizer = createCompletionNormalizer({
+                    capabilities,
+                    tools: request.tools ?? [],
+                    captureThinking: request.captureThinking ?? false,
+                    emitRawDeltas: request.emitRawDeltas ?? false,
+                    toolDialect: dialect,
+                });
                 const stream = completion({
                     history: filteredHistory,
                     modelId: request.modelId,
                     kvCache: request.kvCache,
-                    ...(request.tools && { tools: request.tools }),
+                    ...(toolsActive && request.tools && { tools: request.tools }),
                     ...(request.generationParams && { generationParams: request.generationParams }),
+                    ...(toolsActive && { toolDialect: dialect }),
+                    ...(request.responseFormat && { responseFormat: request.responseFormat }),
                 });
                 try {
-                    let buffer = "";
+                    const batchedEvents = [];
                     let result = await stream.next();
                     while (!result.done) {
+                        const events = normalizer.push(result.value.token);
                         if (request.stream) {
                             yield {
                                 type: "completionStream",
-                                token: result.value.token,
-                                ...(result.value.toolCallEvent && {
-                                    toolCallEvent: result.value.toolCallEvent,
-                                }),
+                                events,
                             };
                         }
                         else {
-                            buffer += result.value.token;
+                            batchedEvents.push(...events);
                         }
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats, toolCalls } = result.value;
+                    const terminalEvents = normalizer.finish({
+                        ...(stats && { stats }),
+                        ...(toolCalls.length > 0 && { toolCalls }),
+                    });
+                    if (!request.stream) {
+                        batchedEvents.push(...terminalEvents);
+                    }
+                    const finalEvents = request.stream ? terminalEvents : batchedEvents;
                     yield attachModelExecutionMs({
                         type: "completionStream",
-                        token: request.stream ? "" : buffer,
                         done: true,
-                        ...(stats && { stats }),
-                        ...(toolCalls.length > 0 && { toolCalls }),
+                        events: finalEvents,
                     }, modelExecutionMs);
                 }
                 finally {

package/dist/server/bare/plugins/llamacpp-embedding/plugin.js

@@ -2,9 +2,7 @@ import EmbedLlamacpp, {} from "@qvac/embed-llamacpp";
 import embedAddonLogging from "@qvac/embed-llamacpp/addonLogging.js";
 import { definePlugin, defineHandler, embedRequestSchema, embedResponseSchema, ModelType, embedConfigBaseSchema, ADDON_EMBEDDING, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
-import { parseModelPath } from "../../../utils/index.js";
-import FilesystemDL from "@qvac/dl-filesystem";
-import { asLoader } from "../../utils/loader-adapter.js";
+import { expandGGUFIntoShards } from "../../../utils/index.js";
 import { embed } from "../../ops/embed.js";
 import { forwardModelExecution } from "../../../../profiling/model-execution.js";
 function transformEmbedConfig(embedConfig) {
@@ -40,21 +38,17 @@ function transformEmbedConfig(embedConfig) {
     return config;
 }
 function createEmbeddingsModel(modelId, modelPath, embedConfig) {
-    const { dirPath, basePath } = parseModelPath(modelPath);
-    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, ModelType.llamacppEmbedding);
     registerAddonLogger(modelId, ModelType.llamacppEmbedding, logger);
     const config = transformEmbedConfig(embedConfig);
-    const args = {
-        loader: asLoader(loader),
-        opts: { stats: true },
+    const modelFiles = expandGGUFIntoShards(modelPath);
+    const model = new EmbedLlamacpp({
+        files: { model: modelFiles },
+        config,
         logger,
-        diskPath: dirPath,
-        modelName: basePath,
-        modelPath,
-    };
-    const model = new EmbedLlamacpp(args, config);
-    return { model, loader };
+        opts: { stats: true },
+    });
+    return { model };
 }
 export const embeddingsPlugin = definePlugin({
     modelType: ModelType.llamacppEmbedding,
@@ -63,8 +57,8 @@ export const embeddingsPlugin = definePlugin({
     loadConfigSchema: embedConfigBaseSchema,
     createModel(params) {
         const embedConfig = (params.modelConfig ?? {});
-        const { model, loader } = createEmbeddingsModel(params.modelId, params.modelPath, embedConfig);
-        return { model, loader };
+        const { model } = createEmbeddingsModel(params.modelId, params.modelPath, embedConfig);
+        return { model };
     },
     handlers: {
         embed: defineHandler({