@qvac/sdk 0.12.1 → 0.13.0

package/dist/server/bare/plugins/bci-whispercpp-transcription/plugin.js

@@ -0,0 +1,116 @@
+import bciAddonLogging from "@qvac/bci-whispercpp/addonLogging.js";
+import BCIWhispercpp, {} from "@qvac/bci-whispercpp";
+import { definePlugin, defineHandler, defineDuplexHandler, bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, ModelType, bciConfigSchema, ADDON_BCI, } from "../../../../schemas/index.js";
+import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { bciTranscribe, bciTranscribeStream, } from "../../ops/bci-transcribe.js";
+import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
+function createBciModel(modelId, modelPath, bciConfig) {
+    const logger = createStreamLogger(modelId, ModelType.bciWhispercppTranscription);
+    registerAddonLogger(modelId, ModelType.bciWhispercppTranscription, logger);
+    const args = {
+        files: {
+            model: modelPath,
+        },
+        logger,
+        opts: {
+            stats: true,
+        },
+    };
+    const model = new BCIWhispercpp(args, bciConfig);
+    return { model };
+}
+export const bciPlugin = definePlugin({
+    modelType: ModelType.bciWhispercppTranscription,
+    displayName: "BCI (whisper.cpp)",
+    addonPackage: ADDON_BCI,
+    loadConfigSchema: bciConfigSchema,
+    createModel(params) {
+        const bciConfig = (params.modelConfig ?? {});
+        const { model } = createBciModel(params.modelId, params.modelPath, bciConfig);
+        return { model };
+    },
+    handlers: {
+        bciTranscribe: defineHandler({
+            requestSchema: bciTranscribeRequestSchema,
+            responseSchema: bciTranscribeResponseSchema,
+            streaming: true,
+            // The BCI addon exposes a model-wide hard cancel — the running
+            // neural-signal job is interrupted on `cancel()`.
+            cancel: { scope: "model", hard: true },
+            handler: async function* (request) {
+                const metadata = request.metadata === true;
+                const stream = metadata
+                    ? bciTranscribe({
+                        modelId: request.modelId,
+                        neuralData: request.neuralData,
+                        metadata: true,
+                    }, request.requestId)
+                    : bciTranscribe({
+                        modelId: request.modelId,
+                        neuralData: request.neuralData,
+                    }, request.requestId);
+                try {
+                    let result = await stream.next();
+                    while (!result.done) {
+                        yield metadata
+                            ? {
+                                type: "bciTranscribe",
+                                segment: result.value,
+                            }
+                            : {
+                                type: "bciTranscribe",
+                                text: result.value,
+                            };
+                        result = await stream.next();
+                    }
+                    const { modelExecutionMs, stats } = result.value;
+                    yield attachModelExecutionMs({
+                        type: "bciTranscribe",
+                        text: "",
+                        done: true,
+                        ...(stats && { stats }),
+                    }, modelExecutionMs);
+                }
+                finally {
+                    await stream.return?.(undefined);
+                }
+            },
+        }),
+        bciTranscribeStream: defineDuplexHandler({
+            requestSchema: bciTranscribeStreamRequestSchema,
+            responseSchema: bciTranscribeStreamResponseSchema,
+            streaming: true,
+            duplex: true,
+            // Same model-wide hard cancel surface as `bciTranscribe` — the BCI
+            // addon's `cancel()` tears down the active stream and interrupts the
+            // running window job.
+            cancel: { scope: "model", hard: true },
+            handler: async function* (request, inputStream) {
+                const metadata = request.metadata === true;
+                const iterator = metadata
+                    ? bciTranscribeStream(request.modelId, inputStream, true, request.streamOpts, request.requestId)
+                    : bciTranscribeStream(request.modelId, inputStream, false, request.streamOpts, request.requestId);
+                for await (const value of iterator) {
+                    yield metadata
+                        ? {
+                            type: "bciTranscribeStream",
+                            segment: value,
+                        }
+                        : {
+                            type: "bciTranscribeStream",
+                            text: value,
+                        };
+                }
+                yield {
+                    type: "bciTranscribeStream",
+                    text: "",
+                    done: true,
+                };
+            },
+        }),
+    },
+    logging: {
+        module: bciAddonLogging,
+        namespace: ModelType.bciWhispercppTranscription,
+    },
+});

package/dist/server/bare/plugins/ggml-vla/ops/vla-run.js

@@ -33,6 +33,10 @@ function pickStats(raw) {
     const out = {};
     if (typeof r["vision_ms"] === "number")
         out.vision_ms = r["vision_ms"];
+    if (typeof r["prefill_compute_ms"] === "number")
+        out.prefill_compute_ms = r["prefill_compute_ms"];
+    if (typeof r["prefill_total_ms"] === "number")
+        out.prefill_total_ms = r["prefill_total_ms"];
     if (typeof r["smollm2_compute_ms"] === "number")
         out.smollm2_compute_ms = r["smollm2_compute_ms"];
     if (typeof r["smollm2_total_ms"] === "number")

package/dist/server/bare/plugins/ggml-vla/plugin.d.ts

@@ -28,6 +28,8 @@ export declare const vlaPlugin: {
             chunkSize: import("zod").ZodNumber;
             stats: import("zod").ZodOptional<import("zod").ZodObject<{
                 vision_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                prefill_compute_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+                prefill_total_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
                 smollm2_compute_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
                 smollm2_total_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
                 ode_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -46,6 +48,11 @@ export declare const vlaPlugin: {
                 maxStateDim: import("zod").ZodNumber;
                 tokenizerMaxLength: import("zod").ZodNumber;
                 visionImageSize: import("zod").ZodNumber;
+                numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
+                stateInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    discrete: "discrete";
+                    continuous: "continuous";
+                }>>;
             }, import("zod/v4/core").$strip>;
             backendName: import("zod").ZodNullable<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;

package/dist/server/bare/plugins/ggml-vla/plugin.js

@@ -16,7 +16,7 @@ function wrapVlaModel(inner, loadOpts) {
 }
 export const vlaPlugin = definePlugin({
     modelType: ModelType.ggmlVla,
-    displayName: "VLA (SmolVLA ggml)",
+    displayName: "VLA (SmolVLA / π₀.₅ ggml)",
     addonPackage: ADDON_VLA,
     loadConfigSchema: vlaConfigSchema,
     createModel(params) {

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

@@ -1,6 +1,7 @@
 export { llmPlugin } from "./llamacpp-completion/plugin";
 export { embeddingsPlugin } from "./llamacpp-embedding/plugin";
 export { whisperPlugin } from "./whispercpp-transcription/plugin";
+export { bciPlugin } from "./bci-whispercpp-transcription/plugin";
 export { parakeetPlugin } from "./parakeet-transcription/plugin";
 export { nmtPlugin } from "./nmtcpp-translation/plugin";
 export { ttsPlugin } from "./tts-ggml/plugin";

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

@@ -1,6 +1,7 @@
 export { llmPlugin } from "./llamacpp-completion/plugin.js";
 export { embeddingsPlugin } from "./llamacpp-embedding/plugin.js";
 export { whisperPlugin } from "./whispercpp-transcription/plugin.js";
+export { bciPlugin } from "./bci-whispercpp-transcription/plugin.js";
 export { parakeetPlugin } from "./parakeet-transcription/plugin.js";
 export { nmtPlugin } from "./nmtcpp-translation/plugin.js";
 export { ttsPlugin } from "./tts-ggml/plugin.js";

package/dist/server/bare/plugins/llamacpp-completion/ops/finetune.js

@@ -105,27 +105,29 @@ export async function startFinetune(request, onProgress) {
     try {
         const model = getModel(request.modelId);
         validateExplicitFinetuneOperation(request);
-        // Open a request-scoped lifecycle so finetune slots into the same
-        // registry-driven cancel surface as the streaming inference kinds.
-        // `cancel({ requestId })` and broad `cancel({ modelId, kind: "finetune" })`
-        // both route through this context's signal — the `onAbort` listener
-        // forwards to `model.cancel()` to match the plugin's
-        // `cancel: { scope: "model", hard: true }` declaration. The legacy
-        // `cancelFinetune(modelId)` wrapper below now goes through the
-        // registry instead of touching the addon directly.
-        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+        // Mark RUNNING before the async begin() so an immediate getFinetuneState()
+        // poll observes RUNNING, not IDLE. register is a no-op when a finetune is
+        // already running on this model, so only clear on a failed begin() if this
+        // call actually set the flag.
+        const wasRunning = getRunningFinetuneState(request.modelId);
+        registerRunningFinetune(request.modelId);
+        // Scope the run into the registry so cancel({ requestId }) and
+        // cancel({ modelId, kind: "finetune" }) reach it; onAbort forwards to
+        // model.cancel().
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry()
+            .begin({
             requestId: request.requestId ?? generateServerRequestId(),
             kind: "finetune",
             modelId: request.modelId,
+        })
+            .catch((err) => {
+            if (!wasRunning)
+                clearFinetuneRuntimeState(request.modelId);
+            throw err;
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
-        registerRunningFinetune(request.modelId);
-        // Two-level try/finally collapses into a pair of `scope.defer`
-        // registrations. LIFO order — the listener-detach defer is
-        // registered after `clearFinetuneRuntimeState`, so on scope unwind
-        // the listener is removed first, then the runtime-state flag is
-        // cleared. This mirrors the legacy `finally` nesting where the inner
-        // `removeListener` ran before the outer `clearFinetuneRuntimeState`.
+        // Cleared on scope unwind; deferred before the listener detach so LIFO
+        // removes the listener first.
         ctx.scope.defer(() => {
             clearFinetuneRuntimeState(request.modelId);
         });
@@ -172,20 +174,11 @@ export async function pauseFinetune(modelId) {
         status: "PAUSED",
     };
 }
-// Thin compat wrapper over the request registry. The in-flight
-// finetune is tracked by a `RequestContext` (kind `"finetune"`), and
-// the registry owns the broadcast to its `AbortSignal`. `startFinetune`
-// installs the addon-level `model.cancel()` listener tied to that
-// signal, so callers see the same observable effect as a direct
-// `model.cancel()` call. The addon-call wiring is centralised there —
-// never invoke `model.cancel()` here.
+// Routes cancellation through the registry; the model.cancel() forward is
+// installed by startFinetune, so never call model.cancel() here.
 export function cancelFinetune(modelId) {
-    // `registry.cancel(...)` is synchronous — it triggers the matching
-    // requests' abort signals and returns the cancelled count. Scope
-    // unwinding (and the `model.cancel()` forward installed by
-    // `startFinetune`) happens on the handler's own dispose path. The
-    // outer `Promise.resolve(...)` keeps the legacy `cancelFinetune`
-    // return shape (`Promise<FinetuneResult>`) intact for callers.
+    // cancel() is synchronous; Promise.resolve keeps the Promise<FinetuneResult>
+    // return shape.
     getRequestRegistry().cancel({ modelId, kind: "finetune" });
     return Promise.resolve({
         type: "finetune",

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

@@ -59,6 +59,7 @@ export declare const llmPlugin: {
                 vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
@@ -70,6 +71,7 @@ export declare const llmPlugin: {
                 "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
+                bci: "bci";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 classification: "classification";

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

@@ -68,10 +68,18 @@ 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";
 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`);
+        }
+    }
     const modelFiles = expandGGUFIntoShards(modelPath);
     const model = new LlmLlamacpp({
         files: {
@@ -142,12 +150,26 @@ 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, getRequestRegistry().begin({
+                    const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
                         requestId: request.requestId ?? generateServerRequestId(),
                         kind: "completion",
                         modelId: request.modelId,
                     }), 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,
@@ -174,17 +196,26 @@ export const llmPlugin = definePlugin({
                             result = await stream.next();
                         }
                         const { modelExecutionMs, stats, toolCalls } = result.value;
-                        // `stopReason: "cancelled"` rides the success-done path: the
-                        // events stream ends normally, the cancellation is observable
-                        // via the last event's `stopReason`, and the client-side
-                        // `CompletionRun` aggregates (`final` / `text` / `toolCalls` /
-                        // `stats`) reject with `InferenceCancelledError` carrying the
-                        // partial state.
+                        // 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.
+                        // 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 stoppedByBudget = !cancelled &&
+                            effectivePredict !== undefined &&
+                            effectivePredict > 0 &&
+                            stats?.generatedTokens !== undefined &&
+                            stats.generatedTokens >= effectivePredict;
                         const terminalEvents = normalizer.finish({
                             ...(stats && { stats }),
                             ...(toolCalls.length > 0 && { toolCalls }),
                             ...(cancelled && { stopReason: "cancelled" }),
+                            ...(stoppedByBudget && { stopReason: "length" }),
                         });
                         if (!request.stream) {
                             batchedEvents.push(...terminalEvents);

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

@@ -59,6 +59,7 @@ export declare const embeddingsPlugin: {
                     cpu: "cpu";
                     gpu: "gpu";
                 }>>;
+                contextSize: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;

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

@@ -1,10 +1,12 @@
 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 { createStreamLogger, registerAddonLogger, getServerLogger } from "../../../../logging/index.js";
 import { expandGGUFIntoShards } from "../../../utils/index.js";
 import { embed } from "../../ops/embed.js";
 import { forwardModelExecution } from "../../../../profiling/model-execution.js";
+import { isMobile } from "../../registry/runtime-context-registry.js";
+import { stripMultiGpuKeys } from "../../../utils/multi-gpu-mobile.js";
 function transformEmbedConfig(embedConfig) {
     const config = {
         device: embedConfig.device,
@@ -47,6 +49,12 @@ function createEmbeddingsModel(modelId, modelPath, embedConfig) {
     const logger = createStreamLogger(modelId, ModelType.llamacppEmbedding);
     registerAddonLogger(modelId, ModelType.llamacppEmbedding, logger);
     const config = transformEmbedConfig(embedConfig);
+    if (isMobile()) {
+        const stripped = stripMultiGpuKeys(config);
+        if (stripped.length > 0) {
+            getServerLogger().warn(`[${ModelType.llamacppEmbedding}:${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 EmbedLlamacpp({
         files: { model: modelFiles },

package/dist/server/bare/plugins/nmtcpp-translation/plugin.d.ts

@@ -60,6 +60,7 @@ export declare const nmtPlugin: {
             mt: "mt";
             nb: "nb";
             nn: "nn";
+            no: "no";
             re: "re";
             ro: "ro";
             sq: "sq";
@@ -67,6 +68,7 @@ export declare const nmtPlugin: {
             sv: "sv";
             ta: "ta";
             te: "te";
+            th: "th";
             tr: "tr";
             vi: "vi";
         }>;
@@ -114,6 +116,7 @@ export declare const nmtPlugin: {
             mt: "mt";
             nb: "nb";
             nn: "nn";
+            no: "no";
             re: "re";
             ro: "ro";
             sq: "sq";
@@ -121,6 +124,7 @@ export declare const nmtPlugin: {
             sv: "sv";
             ta: "ta";
             te: "te";
+            th: "th";
             tr: "tr";
             vi: "vi";
         }>;
@@ -143,6 +147,7 @@ export declare const nmtPlugin: {
                 vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
@@ -154,6 +159,7 @@ export declare const nmtPlugin: {
                 "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
+                bci: "bci";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 classification: "classification";
@@ -178,6 +184,7 @@ export declare const nmtPlugin: {
                 vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
@@ -189,6 +196,7 @@ export declare const nmtPlugin: {
                 "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
+                bci: "bci";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 classification: "classification";
@@ -226,6 +234,7 @@ export declare const nmtPlugin: {
                     vla: "vla";
                     "llamacpp-completion": "llamacpp-completion";
                     "whispercpp-transcription": "whispercpp-transcription";
+                    "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                     "llamacpp-embedding": "llamacpp-embedding";
                     "nmtcpp-translation": "nmtcpp-translation";
                     "onnx-tts": "onnx-tts";
@@ -237,6 +246,7 @@ export declare const nmtPlugin: {
                     "ggml-classification": "ggml-classification";
                     llm: "llm";
                     whisper: "whisper";
+                    bci: "bci";
                     nmt: "nmt";
                     parakeet: "parakeet";
                     classification: "classification";
@@ -261,6 +271,7 @@ export declare const nmtPlugin: {
                     vla: "vla";
                     "llamacpp-completion": "llamacpp-completion";
                     "whispercpp-transcription": "whispercpp-transcription";
+                    "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                     "llamacpp-embedding": "llamacpp-embedding";
                     "nmtcpp-translation": "nmtcpp-translation";
                     "onnx-tts": "onnx-tts";
@@ -272,6 +283,7 @@ export declare const nmtPlugin: {
                     "ggml-classification": "ggml-classification";
                     llm: "llm";
                     whisper: "whisper";
+                    bci: "bci";
                     nmt: "nmt";
                     parakeet: "parakeet";
                     classification: "classification";
@@ -296,6 +308,7 @@ export declare const nmtPlugin: {
                     vla: "vla";
                     "llamacpp-completion": "llamacpp-completion";
                     "whispercpp-transcription": "whispercpp-transcription";
+                    "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                     "llamacpp-embedding": "llamacpp-embedding";
                     "nmtcpp-translation": "nmtcpp-translation";
                     "onnx-tts": "onnx-tts";
@@ -307,6 +320,7 @@ export declare const nmtPlugin: {
                     "ggml-classification": "ggml-classification";
                     llm: "llm";
                     whisper: "whisper";
+                    bci: "bci";
                     nmt: "nmt";
                     parakeet: "parakeet";
                     classification: "classification";

package/dist/server/bare/plugins/onnx-ocr/plugin.d.ts

@@ -40,6 +40,7 @@ export declare const ocrPlugin: {
                 vla: "vla";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
                 "nmtcpp-translation": "nmtcpp-translation";
                 "onnx-tts": "onnx-tts";
@@ -51,6 +52,7 @@ export declare const ocrPlugin: {
                 "ggml-classification": "ggml-classification";
                 llm: "llm";
                 whisper: "whisper";
+                bci: "bci";
                 nmt: "nmt";
                 parakeet: "parakeet";
                 classification: "classification";

package/dist/server/bare/plugins/parakeet-transcription/plugin.d.ts

@@ -36,6 +36,10 @@ export declare const parakeetPlugin: {
                 encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
                 decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemFreeMb: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
             segment: import("zod").ZodOptional<import("zod").ZodObject<{
@@ -94,6 +98,10 @@ export declare const parakeetPlugin: {
                 encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
                 decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
                 melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemFreeMb: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
             error: import("zod").ZodOptional<import("zod").ZodString>;
             segment: import("zod").ZodOptional<import("zod").ZodObject<{

package/dist/server/bare/plugins/sdcpp-generation/ops/video.js

@@ -75,7 +75,7 @@ function asVideoModel(model, modelId) {
 export async function* video(request) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: request.requestId ?? generateServerRequestId(),
             kind: "diffusion",
             modelId: request.modelId,
@@ -134,6 +134,12 @@ export async function* video(request) {
             ...(request.vace_strength !== undefined && {
                 vace_strength: request.vace_strength,
             }),
+            ...(request.init_image !== undefined && {
+                init_image: Buffer.from(request.init_image, "base64"),
+            }),
+            ...(request.strength !== undefined && {
+                strength: request.strength,
+            }),
             ...(request.control_frames !== undefined && {
                 control_frames: request.control_frames.map((b64) => Buffer.from(b64, "base64")),
             }),