@qvac/sdk 0.14.1 → 0.15.0

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

@@ -50,26 +50,28 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     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.js";
-import { definePlugin, defineHandler, finetuneRequestSchema, completionStreamRequestSchema, completionStreamResponseSchema, finetuneResponseSchema, translateRequestSchema, translateResponseSchema, ModelType, llmConfigBaseSchema, ADDON_LLM, } from "../../../../schemas/index.js";
-import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.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 { transformLlmConfig } from "./transform.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";
-import { getRequestRegistry, withRequestContext, } from "../../runtime/index.js";
-import { generateServerRequestId } from "../../runtime/request-id.js";
-import { getServerLogger } from "../../../../logging/index.js";
-import { ContextOverflowError } from "../../../../utils/errors-server.js";
-import { isAddonContextOverflowError, parseContextOverflowMessage, } from "./ops/context-overflow.js";
-import { isMobile } from "../../registry/runtime-context-registry.js";
-import { stripMultiGpuKeys } from "../../../utils/multi-gpu-mobile.js";
+import LlmLlamacpp from '@qvac/llm-llamacpp';
+import llmAddonLogging from '@qvac/llm-llamacpp/addonLogging.js';
+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 { expandGGUFIntoShards } from '../../../utils/index.js';
+import { completion } from './ops/completion-stream.js';
+import { batchCompletion } from './ops/batch-completion-stream.js';
+import { finetune } from './ops/finetune.js';
+import { translate } from '../../ops/translate.js';
+import { transformLlmConfig } from './transform.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';
+import { getRequestRegistry, withRequestContext } from '../../runtime/index.js';
+import { generateServerRequestId } from '../../runtime/request-id.js';
+import { getServerLogger } from '../../../../logging/index.js';
+import { ContextOverflowError } from '../../../../utils/errors-server.js';
+import { isAddonContextOverflowError, parseContextOverflowMessage } from './ops/context-overflow.js';
+import { isAddonCancelledError } from './ops/batch-cancelled.js';
+import { isMobile } from '../../registry/runtime-context-registry.js';
+import { stripMultiGpuKeys } from '../../../utils/multi-gpu-mobile.js';
 function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
     const logger = createStreamLogger(modelId, ModelType.llamacppCompletion);
     registerAddonLogger(modelId, ModelType.llamacppCompletion, logger);
@@ -77,24 +79,40 @@ function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
     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`);
+            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`);
         }
     }
     const modelFiles = expandGGUFIntoShards(modelPath);
     const model = new LlmLlamacpp({
         files: {
             model: modelFiles,
-            ...(projectionModelPath && { projectionModel: projectionModelPath }),
+            ...(projectionModelPath && { projectionModel: projectionModelPath })
         },
         config: llmConfigStrings,
         logger,
-        opts: { stats: true },
+        opts: { stats: true }
     });
     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)",
+    displayName: 'LLM (llama.cpp)',
     addonPackage: ADDON_LLM,
     loadConfigSchema: llmConfigBaseSchema,
     async resolveConfig(cfg, ctx) {
@@ -105,34 +123,178 @@ export const llmPlugin = definePlugin({
         const projectionModelPath = await ctx.resolveModelPath(projectionModelSrc);
         return {
             config: llmConfig,
-            artifacts: { projectionModelPath },
+            artifacts: { projectionModelPath }
         };
     },
     createModel(params) {
         const llmConfig = (params.modelConfig ?? {});
-        const { model } = createLlmModel(params.modelId, params.modelPath, llmConfig, params.artifacts?.["projectionModelPath"]);
+        const { model } = createLlmModel(params.modelId, params.modelPath, llmConfig, params.artifacts?.['projectionModelPath']);
         return { model };
     },
     handlers: {
+        batchCompletionStream: defineHandler({
+            requestSchema: batchCompletionStreamRequestSchema,
+            responseSchema: batchCompletionStreamResponseSchema,
+            streaming: true,
+            cancel: { scope: 'model', 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;
+                    }
+                    const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
+                        requestId: request.requestId ?? generateServerRequestId(),
+                        kind: 'batchCompletion',
+                        modelId: request.modelId
+                    }), 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);
+                        }
+                        // Cancelling a batch that still has prompts queued behind the
+                        // `parallel` slot limit fails the whole native batch group with
+                        // a `Cancelled` error (the addon rejects `run()` rather than
+                        // resolving with partial outputs — see continuous-batching docs).
+                        // Ride the same graceful "done" path the non-overflow cancel
+                        // uses: emit cancelled terminals per id so the client surfaces
+                        // `InferenceCancelledError`, not a generic `CompletionFailedError`.
+                        if (ctx.signal.aborted && isAddonCancelledError(err)) {
+                            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,
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: async function* (request) {
-                const env_1 = { stack: [], error: void 0, hasError: false };
+                const env_2 = { stack: [], error: void 0, hasError: false };
                 try {
                     const filteredHistory = request.history.map(({ role, content, attachments }) => ({
                         role,
                         content,
-                        attachments: attachments ?? [],
+                        attachments: attachments ?? []
                     }));
                     const modelCfg = getModelConfig(request.modelId);
-                    const toolsActive = (request.tools?.length ?? 0) > 0 &&
-                        modelCfg.tools === true;
+                    const toolsActive = (request.tools?.length ?? 0) > 0 && modelCfg.tools === true;
                     const capabilities = {
-                        toolCalling: toolsActive ? "textParse" : "none",
-                        thinkingFraming: request.captureThinking ? "thinkTags" : "none",
+                        toolCalling: toolsActive ? 'textParse' : 'none',
+                        thinkingFraming: request.captureThinking ? 'thinkTags' : 'none'
                     };
                     // Dialect runs regardless of tool availability — thinking/content
                     // stripping is needed even on plain completions.
@@ -142,7 +304,7 @@ export const llmPlugin = definePlugin({
                         tools: request.tools ?? [],
                         captureThinking: request.captureThinking ?? false,
                         emitRawDeltas: request.emitRawDeltas ?? false,
-                        toolDialect: dialect,
+                        toolDialect: dialect
                     });
                     // Open a request-scoped lifecycle. The registry is the single
                     // source of truth for "is this turn cancelled?" — we plumb the
@@ -150,10 +312,10 @@ export const llmPlugin = definePlugin({
                     // 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.
-                    const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
+                    const ctx = __addDisposableResource(env_2, await getRequestRegistry().begin({
                         requestId: request.requestId ?? generateServerRequestId(),
-                        kind: "completion",
-                        modelId: request.modelId,
+                        kind: 'completion',
+                        modelId: request.modelId
                     }), true);
                     const requestLogger = withRequestContext(getServerLogger(), ctx);
                     // begin() can return already-aborted when the client cancels while
@@ -164,9 +326,9 @@ export const llmPlugin = definePlugin({
                     const abortedBeforeRun = Boolean(ctx.signal.aborted);
                     if (abortedBeforeRun) {
                         yield {
-                            type: "completionStream",
+                            type: 'completionStream',
                             done: true,
-                            events: normalizer.finish({ stopReason: "cancelled" }),
+                            events: normalizer.finish({ stopReason: 'cancelled' })
                         };
                         return;
                     }
@@ -175,9 +337,13 @@ export const llmPlugin = definePlugin({
                         modelId: request.modelId,
                         kvCache: request.kvCache,
                         ...(toolsActive && request.tools && { tools: request.tools }),
-                        ...(request.generationParams && { generationParams: request.generationParams }),
+                        ...(request.generationParams && {
+                            generationParams: request.generationParams
+                        }),
                         ...(toolsActive && { toolDialect: dialect }),
-                        ...(request.responseFormat && { responseFormat: request.responseFormat }),
+                        ...(request.responseFormat && {
+                            responseFormat: request.responseFormat
+                        })
                     }, { signal: ctx.signal, scope: ctx.scope, logger: requestLogger });
                     try {
                         const batchedEvents = [];
@@ -186,8 +352,8 @@ export const llmPlugin = definePlugin({
                             const events = normalizer.push(result.value.token);
                             if (request.stream) {
                                 yield {
-                                    type: "completionStream",
-                                    events,
+                                    type: 'completionStream',
+                                    events
                                 };
                             }
                             else {
@@ -204,8 +370,7 @@ export const llmPlugin = definePlugin({
                         // When generatedTokens >= effectivePredict the run exhausted its
                         // token budget without hitting EOS — emit stopReason "length".
                         // -1 (unlimited) and -2 (context fill) must never trigger this.
-                        const effectivePredict = request.generationParams?.predict ??
-                            modelCfg.predict;
+                        const effectivePredict = request.generationParams?.predict ?? modelCfg.predict;
                         const stoppedByBudget = !cancelled &&
                             effectivePredict !== undefined &&
                             effectivePredict > 0 &&
@@ -214,17 +379,17 @@ export const llmPlugin = definePlugin({
                         const terminalEvents = normalizer.finish({
                             ...(stats && { stats }),
                             ...(toolCalls.length > 0 && { toolCalls }),
-                            ...(cancelled && { stopReason: "cancelled" }),
-                            ...(stoppedByBudget && { stopReason: "length" }),
+                            ...(cancelled && { stopReason: 'cancelled' }),
+                            ...(stoppedByBudget && { stopReason: 'length' })
                         });
                         if (!request.stream) {
                             batchedEvents.push(...terminalEvents);
                         }
                         const finalEvents = request.stream ? terminalEvents : batchedEvents;
                         yield attachModelExecutionMs({
-                            type: "completionStream",
+                            type: 'completionStream',
                             done: true,
-                            events: finalEvents,
+                            events: finalEvents
                         }, modelExecutionMs);
                     }
                     catch (err) {
@@ -237,7 +402,7 @@ export const llmPlugin = definePlugin({
                         // class (and `err.code === SDK_SERVER_ERROR_CODES.CONTEXT_OVERFLOW`)
                         // instead of substring-matching on the raw addon message.
                         if (isAddonContextOverflowError(err)) {
-                            const { promptTokens, ctxSize } = parseContextOverflowMessage(err instanceof Error ? err.message : "");
+                            const { promptTokens, ctxSize } = parseContextOverflowMessage(err instanceof Error ? err.message : '');
                             throw new ContextOverflowError(promptTokens, ctxSize, request.modelId, err);
                         }
                         throw err;
@@ -246,16 +411,16 @@ export const llmPlugin = definePlugin({
                         await stream.return?.(undefined);
                     }
                 }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
+                catch (e_2) {
+                    env_2.error = e_2;
+                    env_2.hasError = true;
                 }
                 finally {
-                    const result_1 = __disposeResources(env_1);
-                    if (result_1)
-                        await result_1;
+                    const result_2 = __disposeResources(env_2);
+                    if (result_2)
+                        await result_2;
                 }
-            },
+            }
         }),
         finetune: defineHandler({
             requestSchema: finetuneRequestSchema,
@@ -268,40 +433,40 @@ export const llmPlugin = definePlugin({
             // `cancel({ modelId, kind: "finetune" })` and legacy
             // `cancelFinetune(modelId)` paths both flow through the
             // registry.
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', hard: true },
             handler: function (request) {
                 return finetune(request);
-            },
+            }
         }),
         translate: defineHandler({
             requestSchema: translateRequestSchema,
             responseSchema: translateResponseSchema,
             streaming: true,
-            cancel: { scope: "model", hard: true },
+            cancel: { scope: 'model', 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,
+                            type: 'translate',
+                            token: result.value
                         };
                         result = await stream.next();
                     }
                     const { modelExecutionMs, stats } = result.value;
                     yield attachModelExecutionMs({
-                        type: "translate",
-                        token: "",
+                        type: 'translate',
+                        token: '',
                         done: true,
-                        ...(stats && { stats }),
+                        ...(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 : "");
+                        const { promptTokens, ctxSize } = parseContextOverflowMessage(err instanceof Error ? err.message : '');
                         throw new ContextOverflowError(promptTokens, ctxSize, request.modelId, err);
                     }
                     throw err;
@@ -309,11 +474,11 @@ export const llmPlugin = definePlugin({
                 finally {
                     await stream.return?.(undefined);
                 }
-            },
-        }),
+            }
+        })
     },
     logging: {
         module: llmAddonLogging,
-        namespace: ModelType.llamacppCompletion,
-    },
+        namespace: ModelType.llamacppCompletion
+    }
 });

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

@@ -1,4 +1,4 @@
-import { type LlmConfig } from "../../../../schemas/index";
+import { type LlmConfig } from '../../../../schemas/index';
 /**
  * Converts an LlmConfig into the flat string-keyed map the C++ addon expects.
  *

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

@@ -1,4 +1,4 @@
-import { TOOLS_MODE } from "../../../../schemas/index.js";
+import { TOOLS_MODE } from '../../../../schemas/index.js';
 /**
  * Converts an LlmConfig into the flat string-keyed map the C++ addon expects.
  *
@@ -7,28 +7,28 @@ import { TOOLS_MODE } from "../../../../schemas/index.js";
  *   - 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"
+    const transformed = JSON.parse(JSON.stringify(llmConfig, (key, v) => key === 'modelType' || key === 'system_prompt'
         ? undefined
-        : key === "stop_sequences"
+        : key === 'stop_sequences'
             ? Array.isArray(v)
-                ? v.join(", ")
+                ? v.join(', ')
                 : v
-            : typeof v === "number" || typeof v === "boolean"
+            : 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 ('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"];
+    if ('opencl_cache_dir' in transformed) {
+        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";
+    if ('tools_mode' in transformed) {
+        if (transformed['tools_mode'] === TOOLS_MODE.dynamic) {
+            transformed['tools_compact'] = 'true';
         }
-        delete transformed["tools_mode"];
+        delete transformed['tools_mode'];
     }
     return transformed;
 }

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
 export declare const embeddingsPlugin: {
     modelType: "llamacpp-embedding";
     displayName: string;
@@ -6,8 +6,8 @@ export declare const embeddingsPlugin: {
     loadConfigSchema: import("zod").ZodObject<{
         gpuLayers: import("zod").ZodOptional<import("zod").ZodNumber>;
         device: import("zod").ZodOptional<import("zod").ZodEnum<{
-            cpu: "cpu";
             gpu: "gpu";
+            cpu: "cpu";
         }>>;
         batchSize: import("zod").ZodOptional<import("zod").ZodNumber>;
         pooling: import("zod").ZodOptional<import("zod").ZodEnum<{
@@ -56,8 +56,8 @@ export declare const embeddingsPlugin: {
                 tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
                 backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    cpu: "cpu";
                     gpu: "gpu";
+                    cpu: "cpu";
                 }>>;
                 contextSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;