@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,503 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import LlmLlamacpp from '@qvac/llm-llamacpp';
-import llmAddonLogging from '@qvac/llm-llamacpp/addonLogging';
-import { definePlugin, defineHandler, finetuneRequestSchema, batchCompletionStreamRequestSchema, batchCompletionStreamResponseSchema, completionStreamRequestSchema, completionStreamResponseSchema, finetuneResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, llmConfigBaseSchema, ADDON_LLM } from '../../../../schemas/index.js';
-import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
-import { getFirstShardPath, getModelParallel } from '../../../../server/utils/index.js';
-import { completion } from '../../../../server/bare/plugins/llamacpp-completion/ops/completion-stream.js';
-import { batchCompletion } from '../../../../server/bare/plugins/llamacpp-completion/ops/batch-completion-stream.js';
-import { finetune } from '../../../../server/bare/plugins/llamacpp-completion/ops/finetune.js';
-import { translate } from '../../../../server/bare/ops/translate.js';
-import { transformLlmConfig } from '../../../../server/bare/plugins/llamacpp-completion/transform.js';
-import { attachModelExecutionMs } from '../../../../profiling/model-execution.js';
-import { getModelConfig } from '../../../../server/bare/registry/model-registry.js';
-import { createCompletionNormalizer } from '../../../../server/utils/completion-normalizer.js';
-import { detectToolDialect } from '../../../../server/utils/tool-integration.js';
-import { getRequestRegistry, withRequestContext } from '../../../../server/bare/runtime/index.js';
-import { generateServerRequestId } from '../../../../server/bare/runtime/request-id.js';
-import { getServerLogger } from '../../../../logging/index.js';
-import { ContextOverflowError } from '../../../../utils/errors-server.js';
-import { isAddonContextOverflowError, parseContextOverflowMessage } from '../../../../server/bare/plugins/llamacpp-completion/ops/context-overflow.js';
-import { stoppedByLength } from '../../../../server/bare/plugins/llamacpp-completion/ops/completion-stats.js';
-import { isMobile } from '../../../../server/bare/registry/runtime-context-registry.js';
-import { stripMultiGpuKeys } from '../../../../server/utils/multi-gpu-mobile.js';
-function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
-    const logger = createStreamLogger(modelId, ModelType.llamacppCompletion);
-    registerAddonLogger(modelId, ModelType.llamacppCompletion, logger);
-    const llmConfigStrings = transformLlmConfig(llmConfig);
-    if (isMobile()) {
-        const stripped = stripMultiGpuKeys(llmConfigStrings);
-        if (stripped.length > 0) {
-            getServerLogger().warn(`[${ModelType.llamacppCompletion}:${modelId}] Multi-GPU parameters (${stripped.join(', ')}) are not supported on mobile (single-GPU device) — removing from config; model will load with single-GPU defaults`);
-        }
-    }
-    // Addon overflow flag: at a single slot the addon throws when driven over
-    // capacity, at parallel>1 it queues the surplus. Not on the SDK surface.
-    const rejectWhenBusy = getModelParallel(llmConfig) <= 1;
-    const model = new LlmLlamacpp({
-        files: {
-            model: [getFirstShardPath(modelPath)],
-            ...(projectionModelPath && { projectionModel: projectionModelPath })
-        },
-        config: llmConfigStrings,
-        logger,
-        opts: { stats: true, rejectWhenBusy }
-    });
-    return { model };
-}
-function wrapBatchEvents(id, events) {
-    return events.map((event) => ({ id, event }));
-}
-function createBatchNormalizer(request, dialect, tools, toolsActive) {
-    const capabilities = {
-        toolCalling: toolsActive && tools.length > 0 ? 'textParse' : 'none',
-        thinkingFraming: request.captureThinking ? 'thinkTags' : 'none'
-    };
-    return createCompletionNormalizer({
-        capabilities,
-        tools: toolsActive ? tools : [],
-        captureThinking: request.captureThinking ?? false,
-        emitRawDeltas: request.emitRawDeltas ?? false,
-        toolDialect: request.toolDialect ?? dialect
-    });
-}
-export const llmPlugin = definePlugin({
-    modelType: ModelType.llamacppCompletion,
-    displayName: 'LLM (llama.cpp)',
-    addonPackage: ADDON_LLM,
-    loadConfigSchema: llmConfigBaseSchema,
-    async resolveConfig(cfg, ctx) {
-        const { projectionModelSrc, ...llmConfig } = cfg;
-        if (!projectionModelSrc) {
-            return { config: llmConfig };
-        }
-        const projectionModelPath = await ctx.resolveModelPath(projectionModelSrc);
-        return {
-            config: llmConfig,
-            artifacts: { projectionModelPath }
-        };
-    },
-    createModel(params) {
-        const llmConfig = (params.modelConfig ?? {});
-        const { model } = createLlmModel(params.modelId, params.modelPath, llmConfig, params.artifacts?.['projectionModelPath']);
-        return { model };
-    },
-    handlers: {
-        batchCompletionStream: defineHandler({
-            requestSchema: batchCompletionStreamRequestSchema,
-            responseSchema: batchCompletionStreamResponseSchema,
-            streaming: true,
-            // Request-scope: a model-wide cancel would kill concurrent batching peers.
-            cancel: { scope: 'request', hard: true },
-            handler: async function* (request) {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const dialect = request.toolDialect ?? detectToolDialect(request.modelId);
-                    const modelCfg = getModelConfig(request.modelId);
-                    const toolsActive = modelCfg.tools === true;
-                    const toolsByPosition = request.prompts.map((prompt) => prompt.tools ?? []);
-                    const toolsById = new Map();
-                    const normalizers = new Map();
-                    const bufferedEvents = [];
-                    let ids = [];
-                    function registerIds(addonIds) {
-                        ids = addonIds;
-                        for (const [index, id] of addonIds.entries()) {
-                            toolsById.set(id, toolsByPosition[index] ?? []);
-                        }
-                    }
-                    function getNormalizer(id) {
-                        let normalizer = normalizers.get(id);
-                        if (!normalizer) {
-                            normalizer = createBatchNormalizer(request, dialect, toolsById.get(id) ?? [], toolsActive);
-                            normalizers.set(id, normalizer);
-                        }
-                        return normalizer;
-                    }
-                    // Batches share the completion lane at the `parallel` cap. The cap counts
-                    // requests, not the prompts inside a batch (the addon schedules those).
-                    const parallel = getModelParallel(modelCfg);
-                    const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
-                        requestId: request.requestId ?? generateServerRequestId(),
-                        kind: 'batchCompletion',
-                        modelId: request.modelId,
-                        maxConcurrentPerModel: parallel
-                    }), true);
-                    const requestLogger = withRequestContext(getServerLogger(), ctx);
-                    if (Boolean(ctx.signal.aborted)) {
-                        const abortedIds = request.prompts.map((prompt, index) => prompt.id ?? String(index));
-                        yield {
-                            type: 'batchCompletionStream',
-                            done: true,
-                            ids: abortedIds,
-                            events: abortedIds.flatMap((id) => wrapBatchEvents(id, getNormalizer(id).finish({ stopReason: 'cancelled' })))
-                        };
-                        return;
-                    }
-                    const stream = batchCompletion({
-                        modelId: request.modelId,
-                        prompts: request.prompts
-                    }, { signal: ctx.signal, scope: ctx.scope, logger: requestLogger });
-                    try {
-                        let result = await stream.next();
-                        while (!result.done) {
-                            if (result.value.type === 'ids') {
-                                registerIds(result.value.ids);
-                                yield {
-                                    type: 'batchCompletionStream',
-                                    ids,
-                                    events: []
-                                };
-                            }
-                            else {
-                                const { id, token } = result.value;
-                                const events = wrapBatchEvents(id, getNormalizer(id).push(token));
-                                if (request.stream ?? true) {
-                                    yield {
-                                        type: 'batchCompletionStream',
-                                        events
-                                    };
-                                }
-                                else {
-                                    bufferedEvents.push(...events);
-                                }
-                            }
-                            result = await stream.next();
-                        }
-                        const { modelExecutionMs, stats, results } = result.value;
-                        const terminalEvents = [];
-                        for (const batchResult of results) {
-                            const normalizer = getNormalizer(batchResult.id);
-                            if (normalizer.getAccumulated().rawText.length === 0 && batchResult.output.length > 0) {
-                                terminalEvents.push(...wrapBatchEvents(batchResult.id, normalizer.push(batchResult.output)));
-                            }
-                            // Stats are batch-level (the addon reports one aggregate
-                            // snapshot, not per prompt), so they ride the top-level `stats`
-                            // field on the done frame below — NOT each prompt's terminal.
-                            terminalEvents.push(...wrapBatchEvents(batchResult.id, normalizer.finish({
-                                ...(ctx.signal.aborted && {
-                                    stopReason: 'cancelled'
-                                })
-                            })));
-                        }
-                        const finalEvents = (request.stream ?? true) ? terminalEvents : [...bufferedEvents, ...terminalEvents];
-                        yield attachModelExecutionMs({
-                            type: 'batchCompletionStream',
-                            done: true,
-                            ids,
-                            events: finalEvents,
-                            ...(stats && { stats })
-                        }, modelExecutionMs);
-                    }
-                    catch (err) {
-                        if (isAddonContextOverflowError(err)) {
-                            const { promptTokens, ctxSize } = parseContextOverflowMessage(err instanceof Error ? err.message : '');
-                            throw new ContextOverflowError(promptTokens, ctxSize, request.modelId, err);
-                        }
-                        // Once the registry accepts cancellation, the request signal owns the
-                        // terminal outcome. The addon may reject with different shapes
-                        // depending on whether native sequences were active or queued; those
-                        // transport details must not change the SDK cancellation contract.
-                        if (ctx.signal.aborted) {
-                            const cancelledIds = ids.length > 0
-                                ? ids
-                                : request.prompts.map((prompt, index) => prompt.id ?? String(index));
-                            const cancelledTerminals = cancelledIds.flatMap((id) => wrapBatchEvents(id, getNormalizer(id).finish({ stopReason: 'cancelled' })));
-                            yield {
-                                type: 'batchCompletionStream',
-                                done: true,
-                                ids: cancelledIds,
-                                events: (request.stream ?? true)
-                                    ? cancelledTerminals
-                                    : [...bufferedEvents, ...cancelledTerminals]
-                            };
-                            return;
-                        }
-                        throw err;
-                    }
-                    finally {
-                        await stream.return?.(undefined);
-                    }
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    const result_1 = __disposeResources(env_1);
-                    if (result_1)
-                        await result_1;
-                }
-            }
-        }),
-        completionStream: defineHandler({
-            requestSchema: completionStreamRequestSchema,
-            responseSchema: completionStreamResponseSchema,
-            streaming: true,
-            // Request-scope: a model-wide cancel would kill concurrent batching peers.
-            cancel: { scope: 'request', hard: true },
-            handler: async function* (request) {
-                const env_2 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const filteredHistory = request.history.map(({ role, content, attachments }) => ({
-                        role,
-                        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'
-                    };
-                    // Dialect runs regardless of tool availability — thinking/content
-                    // stripping is needed even on plain completions.
-                    const dialect = request.toolDialect ?? detectToolDialect(request.modelId);
-                    const normalizer = createCompletionNormalizer({
-                        capabilities,
-                        tools: request.tools ?? [],
-                        captureThinking: request.captureThinking ?? false,
-                        emitRawDeltas: request.emitRawDeltas ?? false,
-                        toolDialect: dialect
-                    });
-                    // Open a request-scoped lifecycle. The registry is the single
-                    // source of truth for "is this turn cancelled?" — we plumb the
-                    // signal into `completion()` and expose `requestId` so the
-                    // client can target this run with `cancel({ requestId })`.
-                    // Falls back to a server-generated id if the client (e.g. an
-                    // older release) didn't send one.
-                    // Admit up to `parallel` jobs. Disk-KV-cache turns share this lane too;
-                    // same-file writes serialise per cache path inside the KV-cache session.
-                    const parallel = getModelParallel(modelCfg);
-                    const ctx = __addDisposableResource(env_2, await getRequestRegistry().begin({
-                        requestId: request.requestId ?? generateServerRequestId(),
-                        kind: 'completion',
-                        modelId: request.modelId,
-                        maxConcurrentPerModel: parallel
-                    }), true);
-                    const requestLogger = withRequestContext(getServerLogger(), ctx);
-                    // begin() can return already-aborted when the client cancels while
-                    // this completion is queued behind another same-model one. It never
-                    // decoded, so it must not touch the shared native context — emit a
-                    // cancelled terminal and return. Boolean(...) keeps ctx.signal.aborted
-                    // a boolean so the mid-stream check below isn't narrowed to false.
-                    const abortedBeforeRun = Boolean(ctx.signal.aborted);
-                    if (abortedBeforeRun) {
-                        yield {
-                            type: 'completionStream',
-                            done: true,
-                            events: normalizer.finish({ stopReason: 'cancelled' })
-                        };
-                        return;
-                    }
-                    const stream = completion({
-                        history: filteredHistory,
-                        modelId: request.modelId,
-                        kvCache: request.kvCache,
-                        ...(toolsActive && request.tools && { tools: request.tools }),
-                        ...(request.generationParams && {
-                            generationParams: request.generationParams
-                        }),
-                        ...(toolsActive && { toolDialect: dialect }),
-                        ...(request.responseFormat && {
-                            responseFormat: request.responseFormat
-                        })
-                    }, { signal: ctx.signal, scope: ctx.scope, logger: requestLogger });
-                    try {
-                        const batchedEvents = [];
-                        let result = await stream.next();
-                        while (!result.done) {
-                            const events = normalizer.push(result.value.token);
-                            if (request.stream) {
-                                yield {
-                                    type: 'completionStream',
-                                    events
-                                };
-                            }
-                            else {
-                                batchedEvents.push(...events);
-                            }
-                            result = await stream.next();
-                        }
-                        const { modelExecutionMs, stats, toolCalls, stoppedAtContextBoundary } = result.value;
-                        // Cancellation rides the done path: observable via the last event's
-                        // stopReason; client aggregates reject with InferenceCancelledError.
-                        const cancelled = ctx.signal.aborted;
-                        // EOS tokens are not decoded by llama_decode, so n_eval (and
-                        // therefore stats.generatedTokens) counts only real decode calls.
-                        // Positive prediction-budget exhaustion and a full context window
-                        // both map to stopReason "length"; cancellation takes precedence.
-                        const effectivePredict = request.generationParams?.predict ?? modelCfg.predict;
-                        const lengthStop = stoppedByLength({
-                            cancelled,
-                            effectivePredict,
-                            generatedTokens: stats?.generatedTokens,
-                            stoppedAtContextBoundary
-                        });
-                        const terminalEvents = normalizer.finish({
-                            ...(stats && { stats }),
-                            ...(toolCalls.length > 0 && { toolCalls }),
-                            ...(cancelled && { stopReason: 'cancelled' }),
-                            ...(lengthStop && { stopReason: 'length' })
-                        });
-                        if (!request.stream) {
-                            batchedEvents.push(...terminalEvents);
-                        }
-                        const finalEvents = request.stream ? terminalEvents : batchedEvents;
-                        yield attachModelExecutionMs({
-                            type: 'completionStream',
-                            done: true,
-                            events: finalEvents
-                        }, modelExecutionMs);
-                    }
-                    catch (err) {
-                        // Classify a structured ContextOverflow first, even under an aborted
-                        // signal, so a real overflow racing a cancel surfaces as a typed
-                        // ContextOverflowError.
-                        if (isAddonContextOverflowError(err)) {
-                            const { promptTokens, ctxSize } = parseContextOverflowMessage(err instanceof Error ? err.message : '');
-                            throw new ContextOverflowError(promptTokens, ctxSize, request.modelId, err);
-                        }
-                        // Context overflow is classified above. For every other error after
-                        // accepted cancellation, the request signal owns the terminal outcome
-                        // regardless of the addon's active/queued error shape.
-                        if (ctx.signal.aborted) {
-                            yield attachModelExecutionMs({
-                                type: 'completionStream',
-                                done: true,
-                                events: normalizer.finish({ stopReason: 'cancelled' })
-                            }, 
-                            // The error path has no model execution time to report; omit it
-                            // rather than claim 0.
-                            undefined);
-                            return;
-                        }
-                        throw err;
-                    }
-                    finally {
-                        await stream.return?.(undefined);
-                    }
-                }
-                catch (e_2) {
-                    env_2.error = e_2;
-                    env_2.hasError = true;
-                }
-                finally {
-                    const result_2 = __disposeResources(env_2);
-                    if (result_2)
-                        await result_2;
-                }
-            }
-        }),
-        finetune: defineHandler({
-            requestSchema: finetuneRequestSchema,
-            responseSchema: finetuneResponseSchema,
-            streaming: false,
-            // Reality matches addon: llama.cpp exposes `model.cancel()` for
-            // the running finetune job, so we flip from `scope: "none"` to
-            // `{ scope: "model", hard: true }`. The `startFinetune` op
-            // forwards the registry's abort signal to that call; the broad
-            // `cancel({ modelId, kind: "finetune" })` and legacy
-            // `cancelFinetune(modelId)` paths both flow through the
-            // registry.
-            cancel: { scope: 'model', hard: true },
-            handler: function (request) {
-                return finetune(request);
-            }
-        }),
-        translate: defineHandler({
-            requestSchema: translateRequestSchema,
-            responseSchema: translateResponseSchema,
-            streaming: true,
-            // LLM translate cancels its own run (request-scoped), like completion.
-            cancel: { scope: 'request', hard: true },
-            handler: async function* (request) {
-                const stream = translate(request, request.requestId);
-                try {
-                    let result = await stream.next();
-                    while (!result.done) {
-                        yield {
-                            type: 'translate',
-                            token: result.value
-                        };
-                        result = await stream.next();
-                    }
-                    const { modelExecutionMs, stats } = result.value;
-                    yield attachModelExecutionMs({
-                        type: 'translate',
-                        token: '',
-                        done: true,
-                        ...(stats && { stats })
-                    }, modelExecutionMs);
-                }
-                catch (err) {
-                    // Same addon, same overflow path as `completionStream`. Wrap so
-                    // translate consumers can `instanceof ContextOverflowError` too.
-                    if (isAddonContextOverflowError(err)) {
-                        const { promptTokens, ctxSize } = parseContextOverflowMessage(err instanceof Error ? err.message : '');
-                        throw new ContextOverflowError(promptTokens, ctxSize, request.modelId, err);
-                    }
-                    throw err;
-                }
-                finally {
-                    await stream.return?.(undefined);
-                }
-            }
-        })
-    },
-    logging: {
-        module: llmAddonLogging,
-        namespace: ModelType.llamacppCompletion
-    }
-});

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

@@ -1,10 +0,0 @@
-import { type LlmConfig } from '../../../../schemas/index.js';
-/**
- * Converts an LlmConfig into the flat string-keyed map the C++ addon expects.
- *
- * JS-only fields excluded from the output (must NOT be forwarded to the addon):
- *   - modelType   (schema discriminant, meaningless at C++ level)
- *   - system_prompt  (JS-side history seeding only; C++ removed --system-prompt in 8189)
- */
-export declare function transformLlmConfig(llmConfig: LlmConfig): Record<string, string>;
-//# sourceMappingURL=transform.d.ts.map

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

@@ -1,28 +0,0 @@
-import {} from '../../../../schemas/index.js';
-/**
- * Converts an LlmConfig into the flat string-keyed map the C++ addon expects.
- *
- * JS-only fields excluded from the output (must NOT be forwarded to the addon):
- *   - modelType   (schema discriminant, meaningless at C++ level)
- *   - system_prompt  (JS-side history seeding only; C++ removed --system-prompt in 8189)
- */
-export function transformLlmConfig(llmConfig) {
-    const transformed = JSON.parse(JSON.stringify(llmConfig, (key, v) => key === 'modelType' || key === 'system_prompt'
-        ? 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()}`)}":`));
-    if ('stop_sequences' in transformed) {
-        transformed['reverse_prompt'] = transformed['stop_sequences'];
-        delete transformed['stop_sequences'];
-    }
-    if ('opencl_cache_dir' in transformed) {
-        transformed['openclCacheDir'] = transformed['opencl_cache_dir'];
-        delete transformed['opencl_cache_dir'];
-    }
-    return transformed;
-}

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

@@ -1,77 +0,0 @@
-import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index.js';
-export declare const embeddingsPlugin: {
-    modelType: "llamacpp-embedding";
-    displayName: string;
-    addonPackage: "@qvac/embed-llamacpp";
-    loadConfigSchema: import("zod").ZodObject<{
-        gpuLayers: import("zod").ZodOptional<import("zod").ZodNumber>;
-        device: import("zod").ZodOptional<import("zod").ZodEnum<{
-            gpu: "gpu";
-            cpu: "cpu";
-        }>>;
-        batchSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-        pooling: import("zod").ZodOptional<import("zod").ZodEnum<{
-            none: "none";
-            mean: "mean";
-            cls: "cls";
-            last: "last";
-            rank: "rank";
-        }>>;
-        attention: import("zod").ZodOptional<import("zod").ZodEnum<{
-            causal: "causal";
-            "non-causal": "non-causal";
-        }>>;
-        embdNormalize: import("zod").ZodOptional<import("zod").ZodNumber>;
-        flashAttention: import("zod").ZodOptional<import("zod").ZodEnum<{
-            on: "on";
-            off: "off";
-            auto: "auto";
-        }>>;
-        mainGpu: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodEnum<{
-            integrated: "integrated";
-            dedicated: "dedicated";
-        }>]>>;
-        splitMode: import("zod").ZodOptional<import("zod").ZodEnum<{
-            none: "none";
-            layer: "layer";
-            row: "row";
-        }>>;
-        tensorSplit: import("zod").ZodOptional<import("zod").ZodString>;
-        verbosity: import("zod").ZodOptional<import("zod").ZodEnum<{
-            readonly ERROR: 0;
-            readonly WARN: 1;
-            readonly INFO: 2;
-            readonly DEBUG: 3;
-        }>>;
-        openclCacheDir: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>;
-    createModel(params: CreateModelParams): PluginModelResult;
-    handlers: {
-        embed: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
-            modelId: import("zod").ZodString;
-            text: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
-            type: import("zod").ZodLiteral<"embed">;
-            requestId: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-            type: import("zod").ZodLiteral<"embed">;
-            success: import("zod").ZodBoolean;
-            embedding: import("zod").ZodDefault<import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodNumber>, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>]>>;
-            stats: import("zod").ZodOptional<import("zod").ZodObject<{
-                totalTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
-                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
-                backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    gpu: "gpu";
-                    cpu: "cpu";
-                }>>;
-                contextSize: import("zod").ZodOptional<import("zod").ZodNumber>;
-            }, import("zod/v4/core").$strip>>;
-            error: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>;
-    };
-    logging: {
-        module: import("@qvac/embed-llamacpp/addonLogging").AddonLogging;
-        namespace: "llamacpp-embedding";
-    };
-};
-//# sourceMappingURL=plugin.d.ts.map