@qvac/sdk 0.13.5 → 0.14.0

package/README.md

@@ -16,7 +16,7 @@ See [https://docs.qvac.tether.io/sdk/getting-started](https://docs.qvac.tether.i
 
 For AI/LLM tools, use [https://docs.qvac.tether.io/llms-full.txt](https://docs.qvac.tether.io/llms-full.txt) as the consolidated plaintext documentation export.
 
-> **Assembling a custom worker on Bare?** See [`@qvac/bare-sdk`](../bare-sdk/README.md) — the same SDK surface with no built-in plugin addons, designed for consumers wiring their own worker entry (Pear apps, bare-expo apps, direct Bare scripts).
+> **Running on Bare directly?** `@qvac/sdk` runs on Bare, but you must register the plugins you use explicitly before the first SDK call (Node and Expo do this automatically). For direct Bare usage we recommend [`@qvac/bare-sdk`](../bare-sdk/README.md) — the same SDK surface with no built-in plugin addons, designed for consumers wiring their own worker entry (Pear apps, bare-expo apps, direct Bare scripts).
 
 ## Supported environments and installation
 
@@ -46,7 +46,6 @@ try {
     // Load a model into memory
     const modelId = await loadModel({
         modelSrc: LLAMA_3_2_1B_INST_Q4_0,
-        modelType: "llm",
         onProgress: (progress) => {
             console.log(progress);
         },

package/bare-imports.json

@@ -24,10 +24,6 @@
     "bare": "bare-path",
     "default": "path"
   },
-  "process": {
-    "bare": "bare-process",
-    "default": "process"
-  },
   "readline": {
     "bare": "bare-readline",
     "default": "readline"
@@ -41,4 +37,3 @@
     "default": "node:url"
   }
 }
-

package/dist/client/api/bci-transcribe.js

@@ -3,6 +3,7 @@ import { stream, duplex } from "../rpc/rpc-client.js";
 import { getClientLogger } from "../../logging/index.js";
 import { TranscriptionFailedError } from "../../utils/errors-client.js";
 import { decoratePromise } from "../../utils/decorate-promise.js";
+import { parseClientInput } from "../parse-input.js";
 import { generateClientRequestId } from "./client-request-id.js";
 const logger = getClientLogger();
 function buildBciTranscribeRequest(params, requestId) {
@@ -20,7 +21,7 @@ function buildBciTranscribeRequest(params, requestId) {
     };
 }
 export function bciTranscribe(params, options) {
-    const parsed = bciTranscribeClientParamsSchema.parse(params);
+    const parsed = parseClientInput(bciTranscribeClientParamsSchema, params);
     const requestId = generateClientRequestId();
     const inner = runBciTranscribe(parsed, requestId, options);
     return decoratePromise(inner, { requestId });

package/dist/client/api/download-asset.js

@@ -2,6 +2,7 @@ import { send, stream } from "../rpc/rpc-client.js";
 import { downloadAssetOptionsToRequestSchema, } from "../../schemas/index.js";
 import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
 import { decoratePromise } from "../../utils/decorate-promise.js";
+import { parseClientInput } from "../parse-input.js";
 import { generateClientRequestId } from "./client-request-id.js";
 /**
  * Downloads an asset (model file) without loading it into memory.
@@ -53,7 +54,7 @@ export function downloadAsset(options, rpcOptions) {
     return decoratePromise(inner, { requestId });
 }
 async function runDownloadAsset(options, requestId, rpcOptions) {
-    const request = downloadAssetOptionsToRequestSchema.parse({
+    const request = parseClientInput(downloadAssetOptionsToRequestSchema, {
         ...options,
         requestId,
     });

package/dist/client/api/finetune.js

@@ -1,6 +1,7 @@
 import { send, stream as streamRpc } from "../rpc/rpc-client.js";
 import { finetuneRunParamsSchema, finetuneRunRequestSchema, finetuneStopRequestSchema, finetuneGetStateParamsSchema, finetuneGetStateRequestSchema, finetuneProgressResponseSchema, finetuneResponseSchema, } from "../../schemas/index.js";
 import { InvalidResponseError, StreamEndedError, } from "../../utils/errors-client.js";
+import { parseClientInput } from "../parse-input.js";
 function isFinetuneReplyParams(params) {
     return (params.operation === "pause" ||
         params.operation === "cancel" ||
@@ -8,13 +9,13 @@ function isFinetuneReplyParams(params) {
 }
 function createFinetuneReplyRequest(params) {
     if (params.operation === "getState") {
-        const getStateParams = finetuneGetStateParamsSchema.parse(params);
-        return finetuneGetStateRequestSchema.parse({
+        const getStateParams = parseClientInput(finetuneGetStateParamsSchema, params);
+        return parseClientInput(finetuneGetStateRequestSchema, {
             type: "finetune",
             ...getStateParams,
         });
     }
-    return finetuneStopRequestSchema.parse({
+    return parseClientInput(finetuneStopRequestSchema, {
         type: "finetune",
         modelId: params.modelId,
         operation: params.operation,
@@ -36,7 +37,7 @@ export function finetune(params, rpcOptions) {
         resultPromise.catch(() => { });
         return resultPromise;
     }
-    const runParams = finetuneRunParamsSchema.parse(params);
+    const runParams = parseClientInput(finetuneRunParamsSchema, params);
     let resultResolver = () => { };
     let resultRejecter = () => { };
     const resultPromise = new Promise((resolve, reject) => {
@@ -51,7 +52,7 @@ export function finetune(params, rpcOptions) {
     const processResponses = async () => {
         try {
             let sawTerminalResponse = false;
-            const request = finetuneRunRequestSchema.parse({
+            const request = parseClientInput(finetuneRunRequestSchema, {
                 type: "finetune",
                 ...runParams,
                 withProgress: true,

package/dist/client/api/index.d.ts

@@ -4,6 +4,7 @@ export { completion } from "./completion-stream";
 export { deleteCache } from "./delete-cache";
 export { unloadModel } from "./unload-model";
 export { loggingStream } from "./logging-stream";
+export { subscribeServerLogs, type ServerLogHandler } from "./subscribe-logs";
 export { heartbeat } from "./heartbeat";
 export { transcribe, transcribeStream } from "./transcribe";
 export { bciTranscribe, bciTranscribeStream } from "./bci-transcribe";

package/dist/client/api/index.js

@@ -4,6 +4,7 @@ export { completion } from "./completion-stream.js";
 export { deleteCache } from "./delete-cache.js";
 export { unloadModel } from "./unload-model.js";
 export { loggingStream } from "./logging-stream.js";
+export { subscribeServerLogs } from "./subscribe-logs.js";
 export { heartbeat } from "./heartbeat.js";
 export { transcribe, transcribeStream } from "./transcribe.js";
 export { bciTranscribe, bciTranscribeStream } from "./bci-transcribe.js";

package/dist/client/api/load-model.d.ts

@@ -32,7 +32,10 @@ export declare function loadModel<S extends ModelDescriptor>(options: LoadModelD
  * @overloadLabel "Load new model"
  * @param options - An object that defines all configuration parameters required for loading the model, including:
  *   - modelSrc: The location from which the model weights are fetched (local path, remote URL, or Hyperdrive URL)
- *   - modelType: The type of model ("llm", "whisper", "embeddings", "nmt", or "tts")
+ *   - modelType: The canonical type of model ("llamacpp-completion",
+ *     "whispercpp-transcription", "llamacpp-embedding", "nmtcpp-translation",
+ *     "tts-ggml", ...). May be omitted when `modelSrc` is a registry descriptor
+ *     that already carries the engine.
  *   - modelConfig: Model-specific configuration options (companion sources, model parameters, etc.)
  *   - onProgress: Callback for download progress updates
  *   - logger: Logger instance for model operation logs
@@ -49,27 +52,27 @@ export declare function loadModel<S extends ModelDescriptor>(options: LoadModelD
  * // Local file path - absolute path
  * const localModelId = await loadModel({
  *   modelSrc: "/home/user/models/llama-7b.gguf",
- *   modelType: "llm",
+ *   modelType: "llamacpp-completion",
  *   modelConfig: { ctx_size: 2048 }
  * });
  *
  * // Local file path - relative path
  * const relativeModelId = await loadModel({
  *   modelSrc: "./models/whisper-base.gguf",
- *   modelType: "whisper"
+ *   modelType: "whispercpp-transcription"
  * });
  *
  * // Hyperdrive URL with key and path
  * const hyperdriveId = await loadModel({
  *   modelSrc: "pear://<hyperdrive-key>/llama-7b.gguf",
- *   modelType: "llm",
+ *   modelType: "llamacpp-completion",
  *   modelConfig: { ctx_size: 2048 }
  * });
  *
  * // Remote HTTP/HTTPS URL with progress tracking
  * const remoteId = await loadModel({
  *   modelSrc: "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_K_M.gguf",
- *   modelType: "llm",
+ *   modelType: "llamacpp-completion",
  *   onProgress: (progress) => {
  *     console.log(`Downloaded: ${progress.percentage}%`);
  *   }
@@ -78,7 +81,7 @@ export declare function loadModel<S extends ModelDescriptor>(options: LoadModelD
  * // Multimodal model with projection
  * const multimodalId = await loadModel({
  *   modelSrc: "https://huggingface.co/.../main-model.gguf",
- *   modelType: "llm",
+ *   modelType: "llamacpp-completion",
  *   modelConfig: {
  *     ctx_size: 512,
  *     projectionModelSrc: "https://huggingface.co/.../projection-model.gguf"
@@ -91,7 +94,7 @@ export declare function loadModel<S extends ModelDescriptor>(options: LoadModelD
  * // Whisper with VAD model
  * const whisperId = await loadModel({
  *   modelSrc: "https://huggingface.co/.../whisper-model.gguf",
- *   modelType: "whisper",
+ *   modelType: "whispercpp-transcription",
  *   modelConfig: {
  *     mode: "caption",
  *     output_format: "plaintext",
@@ -107,7 +110,7 @@ export declare function loadModel<S extends ModelDescriptor>(options: LoadModelD
  *
  * const modelId = await loadModel({
  *   modelSrc: "/path/to/model.gguf",
- *   modelType: "llm",
+ *   modelType: "llamacpp-completion",
  *   logger // Pass logger in options
  * });
  * ```

package/dist/client/api/load-model.js

@@ -1,8 +1,9 @@
 import { send, stream } from "../rpc/rpc-client.js";
 import { startLoggingStreamForModel } from "../logging-stream-registry.js";
-import { loadModelOptionsToRequestSchema, reloadConfigOptionsToRequestSchema, isModelTypeAlias, normalizeModelType, inferModelTypeFromModelSrc, ModelType, } from "../../schemas/index.js";
+import { loadBuiltinToRequestSchema, loadCustomPluginToRequestSchema, reloadConfigOptionsToRequestSchema, isBuiltInModelType, isModelTypeAlias, normalizeModelType, inferModelTypeFromModelSrc, ModelType, } from "../../schemas/index.js";
 import { ModelLoadFailedError, ModelTypeRequiredError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
 import { assertModelSrcMatchesModelType } from "../../utils/load-model-validation.js";
+import { parseClientInput } from "../parse-input.js";
 import { getClientLogger } from "../../logging/index.js";
 import { decoratePromise } from "../../utils/decorate-promise.js";
 import { generateClientRequestId } from "./client-request-id.js";
@@ -64,9 +65,6 @@ async function runLoadModel(options, requestId, rpcOptions) {
                 "on typical mobile devices. Pass a `delegate` to `loadModel(...)` to " +
                 "run generation on a desktop peer instead.";
             logger.warn(message);
-            // Surface via console too - if an RN host app doesn't wire getClientLogger()
-            // to a visible transport, logger.warn alone won't reach the dev.
-            console.warn(message);
         }
     }
     // Splice the client-generated `requestId` onto the resolved options so
@@ -76,8 +74,10 @@ async function runLoadModel(options, requestId, rpcOptions) {
     // and a precise abort when it does.
     resolvedOptions = { ...resolvedOptions, requestId };
     const request = isReloadConfig
-        ? reloadConfigOptionsToRequestSchema.parse(resolvedOptions)
-        : loadModelOptionsToRequestSchema.parse(resolvedOptions);
+        ? parseClientInput(reloadConfigOptionsToRequestSchema, resolvedOptions)
+        : isBuiltInModelType(resolvedOptions["modelType"])
+            ? parseClientInput(loadBuiltinToRequestSchema, resolvedOptions)
+            : parseClientInput(loadCustomPluginToRequestSchema, resolvedOptions);
     const modelLogger = isReloadConfig
         ? undefined
         : resolvedOptions["logger"];

package/dist/client/api/subscribe-logs.d.ts

@@ -0,0 +1,28 @@
+import type { LoggingStreamResponse } from "../../schemas/logging-stream";
+export type ServerLogHandler = (log: LoggingStreamResponse) => void;
+/**
+ * Subscribes to every server-side log through a single stream: SDK server logs,
+ * per-model addon logs (llamacpp, whispercpp, …) for all loaded models, and RAG
+ * logs — without having to open a {@link loggingStream} per id.
+ *
+ * Each delivered log keeps its origin in `log.id`: `SDK_LOG_ID` for SDK server
+ * logs, the model id for model logs, or the RAG workspace key. Use it to tell the
+ * sources apart.
+ *
+ * Internally this opens a {@link loggingStream} on the reserved `SDK_ALL_LOG_ID`
+ * stream that the worker fans every log into.
+ *
+ * @param handler - called once per log line.
+ * @returns a function that stops the subscription.
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = subscribeServerLogs((log) => {
+ *   console.log(`[${log.level}] ${log.id} ${log.namespace}: ${log.message}`);
+ * });
+ * // later
+ * unsubscribe();
+ * ```
+ */
+export declare function subscribeServerLogs(handler: ServerLogHandler): () => void;
+//# sourceMappingURL=subscribe-logs.d.ts.map

package/dist/client/api/subscribe-logs.js

@@ -0,0 +1,43 @@
+import { getClientLogger, SDK_ALL_LOG_ID } from "../../logging/index.js";
+import { loggingStream } from "./logging-stream.js";
+const logger = getClientLogger();
+/**
+ * Subscribes to every server-side log through a single stream: SDK server logs,
+ * per-model addon logs (llamacpp, whispercpp, …) for all loaded models, and RAG
+ * logs — without having to open a {@link loggingStream} per id.
+ *
+ * Each delivered log keeps its origin in `log.id`: `SDK_LOG_ID` for SDK server
+ * logs, the model id for model logs, or the RAG workspace key. Use it to tell the
+ * sources apart.
+ *
+ * Internally this opens a {@link loggingStream} on the reserved `SDK_ALL_LOG_ID`
+ * stream that the worker fans every log into.
+ *
+ * @param handler - called once per log line.
+ * @returns a function that stops the subscription.
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = subscribeServerLogs((log) => {
+ *   console.log(`[${log.level}] ${log.id} ${log.namespace}: ${log.message}`);
+ * });
+ * // later
+ * unsubscribe();
+ * ```
+ */
+export function subscribeServerLogs(handler) {
+    const streamIterator = loggingStream({ id: SDK_ALL_LOG_ID });
+    void (async () => {
+        try {
+            for await (const log of streamIterator) {
+                handler(log);
+            }
+        }
+        catch (error) {
+            logger.error("Server log stream error:", error);
+        }
+    })();
+    return () => {
+        void streamIterator.return(undefined);
+    };
+}

package/dist/client/api/text-to-speech.js

@@ -2,6 +2,7 @@ import { textToSpeechStreamResponseSchema, ttsClientParamsSchema, } from "../../
 import { stream as streamRpc, duplex } from "../rpc/rpc-client.js";
 import { getClientLogger } from "../../logging/index.js";
 import { TextToSpeechStreamFailedError } from "../../utils/errors-client.js";
+import { parseClientInput } from "../parse-input.js";
 const logger = getClientLogger();
 /**
  * Fan-out queue that lets multiple consumers iterate the same TTS response
@@ -190,7 +191,7 @@ function buildTextToSpeechStreamRequest(params) {
  *         with `stream: false`, or when the underlying RPC stream errors.
  */
 export function textToSpeech(params, options) {
-    const parsed = ttsClientParamsSchema.parse(params);
+    const parsed = parseClientInput(ttsClientParamsSchema, params);
     if (parsed.sentenceStream && !parsed.stream) {
         throw new TextToSpeechStreamFailedError("textToSpeech: `sentenceStream: true` requires `stream: true`");
     }

package/dist/client/config-loader/config-utils.js

@@ -1,12 +1,10 @@
 import { qvacConfigSchema } from "../../schemas/index.js";
 import { ConfigValidationFailedError } from "../../utils/errors-client.js";
+import { formatZodError } from "../../utils/zod-error.js";
 export function validateConfig(config) {
     const result = qvacConfigSchema.safeParse(config);
     if (!result.success) {
-        const errors = result.error.issues
-            .map((e) => `${String(e.path.join("."))}:  ${e.message}`)
-            .join(", ");
-        throw new ConfigValidationFailedError(errors);
+        throw new ConfigValidationFailedError(formatZodError(result.error));
     }
     return result.data;
 }

package/dist/client/config-loader/resolve-config.bare.js

@@ -4,14 +4,15 @@
  */
 import fs from "bare-fs";
 import path from "bare-path";
-import process from "bare-process";
+import os from "bare-os";
+import env from "bare-env";
 import { validateConfig } from "./config-utils.js";
 import { ConfigFileInvalidError, ConfigFileParseFailedError, } from "../../utils/errors-client.js";
 import { getClientLogger } from "../../logging/index.js";
 const SUPPORTED_CONFIG_FILE_EXTS = [".js", ".json"];
 const logger = getClientLogger();
 function findProjectRoot() {
-    return process.cwd();
+    return os.cwd();
 }
 function fileExists(filePath) {
     return fs.existsSync(filePath);
@@ -50,7 +51,7 @@ function findConfigFile(searchDir) {
  */
 // eslint-disable-next-line @typescript-eslint/require-await -- matches Node/Expo resolver signature
 export async function resolveConfig() {
-    const configPath = process.env["QVAC_CONFIG_PATH"];
+    const configPath = env["QVAC_CONFIG_PATH"];
     if (configPath) {
         const normalizedPath = path.resolve(configPath);
         if (fileExists(normalizedPath)) {

package/dist/client/parse-input.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare function parseClientInput<S extends z.ZodType>(schema: S, value: unknown): z.output<S>;
+//# sourceMappingURL=parse-input.d.ts.map

package/dist/client/parse-input.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { formatZodError } from "../utils/zod-error.js";
+import { RequestValidationFailedError } from "../utils/errors-client.js";
+export function parseClientInput(schema, value) {
+    try {
+        return schema.parse(value);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new RequestValidationFailedError(formatZodError(error));
+        }
+        throw error;
+    }
+}

package/dist/client/rpc/expo-rpc-client.js

@@ -151,11 +151,8 @@ export async function close() {
         logger.info("🧹 Closing RPC client (Expo)");
         // terminate() crashes on Android (addon dlclose leaves pthread_key_t
         // destructors dangling); iOS dyld no-ops dlclose so it's safe there.
-        // Non-iOS: send the cleanup roundtrip, then drop refs without
-        // terminating. Android cannot safely terminate/dlclose the worklet
-        // here, but reset/reload still needs addon logger js_ref_t handles
-        // released before a fresh worker registers plugins in the same app
-        // process.
+        // Non-iOS: drop refs only -- sending __shutdown__ without a follow-up
+        // terminate would clear the worker plugin registry.
         let platform;
         try {
             platform = (await getRuntimeContext()).platform;
@@ -164,14 +161,8 @@ export async function close() {
             logger.debug("Failed to resolve runtime context for close()", { err });
         }
         if (platform !== "ios") {
-            if (rpcInstance) {
-                logger.info("🧹 Requesting worker cleanup");
-                await sendShutdownMessage(rpcInstance);
-            }
             rpcInstance = null;
             rpcPromise = null;
-            workletInstance = null;
-            workletInitialized = false;
             return;
         }
         // iOS: existing pre-terminate cleanup + terminate.

package/dist/client/rpc/node-rpc-client.js

@@ -9,11 +9,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { initializeConfig } from "../init-hooks.js";
 import { resolveConfig } from "../config-loader/resolve-config.node.js";
-import { getClientLogger } from "../../logging/index.js";
+import { getClientLogger, getLogger, SDK_SERVER_NAMESPACE } from "../../logging/index.js";
 import { BareRuntimeBinaryNotFoundError, RPCInitTimeoutError, WorkerCrashedError, WorkerShutdownError, } from "../../utils/errors-client.js";
 const RPC_INIT_TIMEOUT_MS = 30_000;
 const WORKER_STDERR_TAIL_CHARS = 16_384;
 const logger = getClientLogger();
+// Addons route real logs through their JS callback; anything written straight to the
+// worker's stderr is treated as debug.
+const workerLogger = getLogger(SDK_SERVER_NAMESPACE, { enableConsole: false });
 let rpcInstance = null;
 let rpcPromise = null;
 let bareWorkerProc = null;
@@ -339,7 +342,10 @@ async function ensureRPC() {
                 getWorkerStderr(bareWorkerProc)?.on("data", (chunk) => {
                     const text = chunk.toString();
                     workerStderrTail = appendWorkerStderrTail(workerStderrTail, text);
-                    process.stderr.write(chunk);
+                    for (const line of text.split("\n")) {
+                        if (line.trim())
+                            workerLogger.debug(line);
+                    }
                 });
                 bareWorkerProc.on("exit", (code, exitSignal) => {
                     if (settled) {

package/dist/client/rpc/rpc-client.js

@@ -3,7 +3,9 @@ import { reconstructError } from "./rpc-error.js";
 import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
 import { getClientLogger, summarizeRequest } from "../../logging/index.js";
 import { getRPC, close as closeRPC, createDuplexSession, getWorkerLifeSignal, } from "#rpc";
-import { WorkerCrashedError } from "../../utils/errors-client.js";
+import { WorkerCrashedError, RequestValidationFailedError, } from "../../utils/errors-client.js";
+import { formatZodError } from "../../utils/zod-error.js";
+import { z } from "zod";
 import { nowMs, shouldProfile, shouldIncludeServerBreakdown, generateId as createProfileId, createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta, recordFailure, } from "../../profiling/index.js";
 import { createClientTimings, createClientStreamTimings, recordClientEvents, recordClientStreamEvents, cacheConnectionTime, flushConnectionTime, resetConnectionTracking, } from "./profiling/index.js";
 const logger = getClientLogger();
@@ -14,6 +16,36 @@ function getNextCommandId() {
     commandCounter = (commandCounter + 1) % Number.MAX_SAFE_INTEGER;
     return commandCounter;
 }
+function memberDiscriminator(option) {
+    const direct = option.shape?.type?.value;
+    if (typeof direct === "string")
+        return direct;
+    const nested = option.options?.[0]?.shape?.type?.value;
+    return typeof nested === "string" ? nested : undefined;
+}
+function pinpointRequestError(request, fallback) {
+    const type = request?.type;
+    if (typeof type !== "string")
+        return fallback;
+    for (const option of requestSchema.options) {
+        if (memberDiscriminator(option) !== type)
+            continue;
+        const result = option.safeParse(request);
+        return result.success ? fallback : result.error;
+    }
+    return fallback;
+}
+function parseRequest(request) {
+    try {
+        return requestSchema.parse(request);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new RequestValidationFailedError(formatZodError(pinpointRequestError(request, error)));
+        }
+        throw error;
+    }
+}
 // Race in-flight reply/stream pulls against the worker-life signal —
 // bare-rpc's `_onerror` does not iterate `_outgoingRequests`, so without
 // this they hang on a dead socket.
@@ -164,7 +196,7 @@ export async function send(request, options, rpc) {
     return sendProfiled(request, ctx.rpc, options);
 }
 async function sendBase(request, rpc, options, signalDisable = false) {
-    const parsedRequest = requestSchema.parse(request);
+    const parsedRequest = parseRequest(request);
     const req = rpc.request(getNextCommandId());
     logger.debug("RPC Client sending:", summarizeRequest(request));
     const payloadObj = signalDisable
@@ -185,7 +217,7 @@ async function sendProfiled(request, rpc, options) {
     const timings = createClientTimings(profileId, requestType);
     try {
         const zodStart = nowMs();
-        const parsedRequest = requestSchema.parse(request);
+        const parsedRequest = parseRequest(request);
         timings.requestZodValidationMs = nowMs() - zodStart;
         const req = rpc.request(getNextCommandId());
         logger.debug("RPC Client sending:", summarizeRequest(request));
@@ -234,7 +266,7 @@ export async function* stream(request, options = {}, rpc) {
     yield* streamProfiled(request, ctx.rpc, options);
 }
 async function* streamBase(request, rpc, options = {}, signalDisable = false) {
-    const parsedRequest = requestSchema.parse(request);
+    const parsedRequest = parseRequest(request);
     const req = rpc.request(getNextCommandId());
     logger.debug("RPC Client streaming:", summarizeRequest(request));
     const payloadObj = signalDisable
@@ -271,7 +303,7 @@ async function* streamProfiled(request, rpc, options = {}) {
     let profilingMeta = undefined;
     try {
         const zodStart = nowMs();
-        const parsedRequest = requestSchema.parse(request);
+        const parsedRequest = parseRequest(request);
         timings.requestZodValidationMs = nowMs() - zodStart;
         const req = rpc.request(getNextCommandId());
         logger.debug("RPC Client streaming:", summarizeRequest(request));
@@ -344,7 +376,7 @@ export async function duplex(request, options) {
     return duplexProfiled(request, options);
 }
 async function duplexBase(request, signalDisable, timeout) {
-    const parsedRequest = requestSchema.parse(request);
+    const parsedRequest = parseRequest(request);
     logger.debug("RPC Client duplex:", summarizeRequest(request));
     const payloadObj = signalDisable
         ? injectProfilingMetaIntoObject(parsedRequest, createProfilingDisabledMeta())
@@ -365,7 +397,7 @@ async function duplexProfiled(request, options = {}) {
     let session;
     try {
         const zodStart = nowMs();
-        const parsedRequest = requestSchema.parse(request);
+        const parsedRequest = parseRequest(request);
         timings.requestZodValidationMs = nowMs() - zodStart;
         logger.debug("RPC Client duplex:", summarizeRequest(request));
         const requestMeta = createProfilingMeta(profileId, includeServer);

package/dist/commands/bundle/constants.js

@@ -6,9 +6,10 @@ export const BUILTIN_PLUGINS = {
     "parakeet-transcription": { exportName: "parakeetPlugin" },
     "nmtcpp-translation": { exportName: "nmtPlugin" },
     "tts-ggml": { exportName: "ttsPlugin" },
-    "onnx-ocr": { exportName: "ocrPlugin" },
+    "ggml-ocr": { exportName: "ocrPlugin" },
     "sdcpp-generation": { exportName: "diffusionPlugin" },
     "ggml-vla": { exportName: "vlaPlugin" },
+    "ggml-classification": { exportName: "classificationPlugin" },
 };
 export const BUILTIN_SUFFIXES = Object.keys(BUILTIN_PLUGINS);
 export const DEFAULT_HOSTS = [

package/dist/examples/bci/bci-filesystem-streaming.js

@@ -19,10 +19,10 @@ const neuralFilePath = args[0];
 // Feed the neural buffer in fixed-size chunks to simulate a live stream.
 const CHUNK_SIZE = 64 * 1024;
 try {
-    console.log("=== BCI transcribeStream file test ===");
-    console.log(`File: ${neuralFilePath}`);
-    console.log(`Chunk size: ${CHUNK_SIZE} bytes\n`);
-    console.log("Loading model...");
+    console.log("▸ BCI transcribeStream file test");
+    console.log(`▸ File: ${neuralFilePath}`);
+    console.log(`▸ Chunk size: ${CHUNK_SIZE} bytes`);
+    console.log("▸ Loading model...");
     const modelId = await loadModel({
         modelSrc: BCI_WINDOWED,
         modelConfig: {
@@ -38,10 +38,10 @@ try {
             },
         },
     });
-    console.log(`Model loaded: ${modelId}\n`);
-    console.log("Opening live session...");
+    console.log(`▸ Model loaded: ${modelId}`);
+    console.log("▸ Opening live session...");
     const session = await bciTranscribeStream({ modelId, emit: "delta" });
-    console.log("Session open. Streaming neural signal...\n");
+    console.log("▸ Session open. Streaming neural signal...");
     // Drain the session concurrently with writing so the sliding-window
     // decode can make progress as chunks arrive instead of stalling.
     const consume = (async () => {
@@ -60,18 +60,18 @@ try {
         totalBytes += chunk.length;
         await new Promise((resolve) => setTimeout(resolve, 10));
     }
-    console.log(`\n\nNeural signal streamed: ${totalBytes} bytes`);
-    console.log("Waiting for transcription to finish...\n");
+    console.log(`\n\n▸ Neural signal streamed: ${totalBytes} bytes`);
+    console.log("▸ Waiting for transcription to finish...");
     session.end();
     const transcript = await consume;
-    console.log("\n=== Results ===");
-    console.log(`Transcript: ${transcript.trim() || "(no text received)"}`);
-    console.log("\nUnloading model...");
+    console.log("\n▸ Results");
+    console.log(transcript.trim() || "(no text received)");
+    console.log("▸ Unloading model...");
     await unloadModel({ modelId });
-    console.log("Done.");
+    console.log("▸ Done.");
     process.exit(0);
 }
 catch (error) {
-    console.error("❌ Error:", error);
+    console.error("✖", error);
     process.exit(1);
 }