@qvac/sdk 0.14.0 → 0.15.0

package/NOTICE

@@ -251,8 +251,14 @@ Third-Party Model Licenses
     https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx
   parakeet-ctc-0.6b-ONNX
     https://huggingface.co/onnx-community/parakeet-ctc-0.6b-ONNX
+  parakeet-ctc-0.6b.f16
+    https://huggingface.co/nvidia/parakeet-ctc-0.6b
+  parakeet-ctc-0.6b.q4_0
+    https://huggingface.co/nvidia/parakeet-ctc-0.6b
   parakeet-ctc-0.6b.q8_0
     https://huggingface.co/nvidia/parakeet-ctc-0.6b
+  parakeet-eou-120m-v1.f16
+    https://huggingface.co/nvidia/parakeet_realtime_eou_120m-v1
   parakeet-eou-120m-v1.q4_0
     https://huggingface.co/nvidia/parakeet_realtime_eou_120m-v1
   parakeet-eou-120m-v1.q8_0
@@ -261,12 +267,16 @@ Third-Party Model Licenses
     https://huggingface.co/altunenes/parakeet-rs
   parakeet-tdt-0.6b-v3-onnx
     https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx
+  parakeet-tdt-0.6b-v3.f16
+    https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3
   parakeet-tdt-0.6b-v3.q4_0
     https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3
   parakeet-tdt-0.6b-v3.q8_0
     https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3
   preprocessor
     https://huggingface.co/istupakov/parakeet-tdt-0.6b-v3-onnx
+  sortformer-4spk-v1.f16
+    https://huggingface.co/nvidia/diar_sortformer_4spk-v1
   sortformer-4spk-v1.q4_0
     https://huggingface.co/nvidia/diar_sortformer_4spk-v1
   sortformer-4spk-v1.q8_0
@@ -301,6 +311,8 @@ Third-Party Model Licenses
     https://huggingface.co/1bitLLM/bitnet_b1_58-large
   bitnet_b1_58-xl-TQ2_0
     https://huggingface.co/1bitLLM/bitnet_b1_58-xl
+  Cangjie5_TC
+    https://github.com/Jackchows/Cangjie5
   chatterbox-multilingual-ONNX
     https://huggingface.co/onnx-community/chatterbox-multilingual-ONNX
   chatterbox-s3gen
@@ -343,6 +355,10 @@ Third-Party Model Licenses
     https://huggingface.co/ChristianAzinn/gte-large-gguf
   gte-large-gguf
     https://huggingface.co/ChristianAzinn/gte-large-gguf
+  lavasr-denoiser-f16
+    https://huggingface.co/spaces/YatharthS
+  lavasr-enhancer-f16
+    https://huggingface.co/spaces/YatharthS
   pt-tiny-ggml-model-f16
     https://huggingface.co/DavyCosta701/whisper-tiny-pt-bpra
   tiny_acft_q8_0
@@ -621,17 +637,17 @@ JavaScript Dependencies
 
   @hyperswarm/secret-stream@6.9.1
     https://github.com/holepunchto/hyperswarm-secret-stream
-  @qvac/bci-whispercpp@0.3.3
+  @qvac/bci-whispercpp@0.4.1
     https://github.com/tetherto/qvac
-  @qvac/classification-ggml@0.7.0
+  @qvac/classification-ggml@0.10.2
     https://github.com/tetherto/qvac
   @qvac/decoder-audio@0.5.0
     https://github.com/tetherto/qvac
   @qvac/diagnostics@0.1.2
     https://github.com/tetherto/qvac
-  @qvac/diffusion-cpp@0.12.0
+  @qvac/diffusion-cpp@0.13.3
     https://github.com/tetherto/qvac
-  @qvac/embed-llamacpp@0.23.0
+  @qvac/embed-llamacpp@0.26.2
     https://github.com/tetherto/qvac
   @qvac/error@0.1.1
   @qvac/infer-base@0.4.2
@@ -640,10 +656,10 @@ JavaScript Dependencies
     https://github.com/tetherto/qvac
   @qvac/langdetect-text@0.1.2
     https://github.com/tetherto/qvac
-  @qvac/llm-llamacpp@0.30.0
+  @qvac/llm-llamacpp@0.36.3
     https://github.com/tetherto/qvac
   @qvac/logging@0.1.0
-  @qvac/ocr-ggml@0.7.0
+  @qvac/ocr-ggml@0.10.2
     https://github.com/tetherto/qvac
   @qvac/rag@0.6.4
     https://github.com/tetherto/qvac
@@ -651,15 +667,15 @@ JavaScript Dependencies
     https://github.com/tetherto/qvac
   @qvac/registry-schema@0.3.0
     https://github.com/tetherto/qvac
-  @qvac/transcription-parakeet@0.8.2
+  @qvac/transcription-parakeet@0.9.1
     https://github.com/tetherto/qvac
-  @qvac/transcription-whispercpp@0.10.2
+  @qvac/transcription-whispercpp@0.11.1
     https://github.com/tetherto/qvac
-  @qvac/translation-nmtcpp@6.3.0
+  @qvac/translation-nmtcpp@7.2.2
     https://github.com/tetherto/qvac
-  @qvac/tts-ggml@0.3.5
+  @qvac/tts-ggml@0.4.2
     https://github.com/tetherto/qvac
-  @qvac/vla-ggml@0.7.0
+  @qvac/vla-ggml@0.11.2
     https://github.com/tetherto/qvac
   adaptive-timeout@1.0.1
     https://github.com/holepunchto/adaptive-timeout

package/README.md

@@ -41,32 +41,31 @@ npm install @qvac/sdk
 3. Create the quickstart script:
 
 ```js
-import { loadModel, LLAMA_3_2_1B_INST_Q4_0, completion, unloadModel } from "@qvac/sdk";
+import { loadModel, LLAMA_3_2_1B_INST_Q4_0, completion, unloadModel } from '@qvac/sdk'
 try {
-    // Load a model into memory
-    const modelId = await loadModel({
-        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
-        onProgress: (progress) => {
-            console.log(progress);
-        },
-    });
-    // You can use the loaded model multiple times
-    const history = [
-        {
-            role: "user",
-            content: "Explain quantum computing in one sentence",
-        },
-    ];
-    const result = completion({ modelId, history, stream: true });
-    for await (const token of result.tokenStream) {
-        process.stdout.write(token);
+  // Load a model into memory
+  const modelId = await loadModel({
+    modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+    onProgress: (progress) => {
+      console.log(progress)
     }
-    // Unload model to free up system resources
-    await unloadModel({ modelId });
-}
-catch (error) {
-    console.error("❌ Error:", error);
-    process.exit(1);
+  })
+  // You can use the loaded model multiple times
+  const history = [
+    {
+      role: 'user',
+      content: 'Explain quantum computing in one sentence'
+    }
+  ]
+  const result = completion({ modelId, history, stream: true })
+  for await (const token of result.tokenStream) {
+    process.stdout.write(token)
+  }
+  // Unload model to free up system resources
+  await unloadModel({ modelId })
+} catch (error) {
+  console.error('❌ Error:', error)
+  process.exit(1)
 }
 ```
 
@@ -120,11 +119,11 @@ npm i path/to/sdk-0.3.0.tgz
 
 The SDK test suite is organized into three buckets by runtime:
 
-| Bucket | Runtime | Location | Command |
-|--------|---------|----------|---------|
-| Unit | Bun / Node | `test/unit/` | `bun run test:unit` |
-| Server (Bare) | Bare | `test/bare/` | `bun run test:bare` |
-| Client (consumer) | Node / RN | `e2e/` | See [`e2e/README.md`](./e2e/README.md) |
+| Bucket            | Runtime    | Location     | Command                                |
+| ----------------- | ---------- | ------------ | -------------------------------------- |
+| Unit              | Bun / Node | `test/unit/` | `bun run test:unit`                    |
+| Server (Bare)     | Bare       | `test/bare/` | `bun run test:bare`                    |
+| Client (consumer) | Node / RN  | `e2e/`       | See [`e2e/README.md`](./e2e/README.md) |
 
 See [`TESTING.md`](./TESTING.md) for the full decision tree on where new tests should land.
 
@@ -200,13 +199,13 @@ Must include BEFORE/AFTER code examples showing the migration path:
 **BEFORE:**
 
 ```typescript
-const model = await loadModel("model-path");
+const model = await loadModel('model-path')
 ```
 
 **AFTER:**
 
 ```typescript
-const modelId = await loadModel("model-path", { modelType: "llm" });
+const modelId = await loadModel('model-path', { modelType: 'llm' })
 ```
 ````
 
@@ -215,10 +214,10 @@ Or using inline comments:
 ````markdown
 ```typescript
 // old
-const model = await loadModel("model-path");
+const model = await loadModel('model-path')
 
 // new
-const modelId = await loadModel("model-path", { modelType: "llm" });
+const modelId = await loadModel('model-path', { modelType: 'llm' })
 ```
 ````
 
@@ -233,9 +232,9 @@ Must include at least one fenced code block showing the new API usage:
 // New completion API with streaming support
 for await (const token of completion({
   modelId,
-  history: [{ role: "user", content: "Hello!" }],
+  history: [{ role: 'user', content: 'Hello!' }]
 }).tokenStream) {
-  process.stdout.write(token);
+  process.stdout.write(token)
 }
 ```
 ````

package/dist/client/api/batch-completion.d.ts

@@ -0,0 +1,15 @@
+import { type BatchCompletionClientParams, type BatchCompletionRun, type BatchCompletionStreamRequest, type McpClientInput, type RPCOptions, type Tool } from '../../schemas/index';
+import { type ToolInput } from '../../utils/tool-helpers';
+type BatchPromptParams = Omit<BatchCompletionClientParams['prompts'][number], 'tools'> & {
+    tools?: Tool[] | ToolInput[];
+    mcp?: McpClientInput[];
+};
+type BatchCompletionParams = Omit<BatchCompletionClientParams, 'prompts' | 'requestId'> & {
+    prompts: BatchPromptParams[];
+    rpcOptions?: RPCOptions;
+};
+type BatchCompletionStreamFactory = (request: BatchCompletionStreamRequest, options?: RPCOptions) => AsyncGenerator<unknown>;
+export declare function batchCompletion(params: BatchCompletionParams): BatchCompletionRun;
+export declare function createBatchCompletionRun(params: BatchCompletionParams, streamFactory: BatchCompletionStreamFactory): BatchCompletionRun;
+export {};
+//# sourceMappingURL=batch-completion.d.ts.map

package/dist/client/api/batch-completion.js

@@ -0,0 +1,332 @@
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { generateClientRequestId } from './client-request-id.js';
+import { getClientLogger } from '../../logging/index.js';
+import { batchCompletionStreamResponseSchema } from '../../schemas/index.js';
+import { buildFinalFromEvents } from '../../utils/aggregate-events.js';
+import { CompletionFailedError, InferenceCancelledError } from '../../utils/errors-server.js';
+import { getMcpToolsWithHandlers } from '../../utils/mcp-adapter.js';
+import { validateTools } from '../../utils/tool-helpers.js';
+const logger = getClientLogger();
+function createPerIdState() {
+    let finalResolver = () => { };
+    let finalRejecter = () => { };
+    const final = new Promise((resolve, reject) => {
+        finalResolver = resolve;
+        finalRejecter = reject;
+    });
+    final.catch(() => { });
+    return {
+        allEvents: [],
+        final,
+        finalResolver,
+        finalRejecter,
+        eventWaiters: [],
+        done: false
+    };
+}
+function addHandlers(target, source) {
+    for (const [name, handler] of source) {
+        if (target.has(name)) {
+            logger.warn(`Duplicate tool handler for "${name}", overwriting`);
+        }
+        target.set(name, handler);
+    }
+}
+async function resolveBatchPrompts(prompts) {
+    const resolvedPrompts = [];
+    const resolvedHandlers = [];
+    for (const prompt of prompts) {
+        let allTools = [];
+        const handlers = new Map();
+        if (prompt.tools) {
+            const { tools, handlers: toolHandlers } = validateTools(prompt.tools);
+            allTools = tools;
+            addHandlers(handlers, toolHandlers);
+        }
+        if (prompt.mcp && prompt.mcp.length > 0) {
+            const { tools: mcpTools, handlers: mcpHandlers } = await getMcpToolsWithHandlers(prompt.mcp);
+            allTools = [...mcpTools, ...allTools];
+            addHandlers(handlers, mcpHandlers);
+        }
+        resolvedHandlers.push(handlers);
+        resolvedPrompts.push({
+            ...(prompt.id !== undefined && { id: prompt.id }),
+            history: prompt.history,
+            ...(prompt.generationParams && {
+                generationParams: prompt.generationParams
+            }),
+            ...(prompt.responseFormat && { responseFormat: prompt.responseFormat }),
+            ...(allTools.length > 0 && { tools: allTools })
+        });
+    }
+    return { prompts: resolvedPrompts, handlers: resolvedHandlers };
+}
+export function batchCompletion(params) {
+    return createBatchCompletionRun(params, streamRpc);
+}
+export function createBatchCompletionRun(params, streamFactory) {
+    const requestId = generateClientRequestId();
+    const states = new Map();
+    const subStreams = new Map();
+    const eventQueue = [];
+    const handlersById = new Map();
+    let handlersByPosition = [];
+    const emptyHandlers = new Map();
+    let eventResolve = null;
+    let idsResolver = () => { };
+    let idsRejecter = () => { };
+    let resultsResolver = () => { };
+    let resultsRejecter = () => { };
+    let statsResolver = () => { };
+    let statsRejecter = () => { };
+    let idsResolved = false;
+    let done = false;
+    let streamError = null;
+    let settledIds = null;
+    const idsPromise = new Promise((resolve, reject) => {
+        idsResolver = resolve;
+        idsRejecter = reject;
+    });
+    idsPromise.catch(() => { });
+    const resultsPromise = new Promise((resolve, reject) => {
+        resultsResolver = resolve;
+        resultsRejecter = reject;
+    });
+    resultsPromise.catch(() => { });
+    const statsPromise = new Promise((resolve, reject) => {
+        statsResolver = resolve;
+        statsRejecter = reject;
+    });
+    statsPromise.catch(() => { });
+    function ensureState(id) {
+        let state = states.get(id);
+        if (!state) {
+            state = createPerIdState();
+            states.set(id, state);
+            if (done) {
+                if (streamError !== null) {
+                    state.finalRejecter(streamError);
+                    state.done = true;
+                }
+                else if (settledIds?.has(id)) {
+                    settleState(id, state);
+                }
+                else {
+                    state.finalRejecter(new CompletionFailedError(`Unknown batch prompt id "${id}".`));
+                    state.done = true;
+                }
+            }
+        }
+        return state;
+    }
+    function notifyWaiters() {
+        if (eventResolve) {
+            eventResolve();
+            eventResolve = null;
+        }
+        for (const state of states.values()) {
+            const waiters = state.eventWaiters.splice(0);
+            for (const resolve of waiters)
+                resolve();
+        }
+    }
+    function resolveIds(ids) {
+        if (idsResolved)
+            return;
+        idsResolved = true;
+        for (const [index, id] of ids.entries()) {
+            handlersById.set(id, handlersByPosition[index] ?? emptyHandlers);
+            ensureState(id);
+        }
+        idsResolver(ids);
+    }
+    function rejectAll(error) {
+        idsRejecter(error);
+        resultsRejecter(error);
+        statsRejecter(error);
+        for (const state of states.values()) {
+            if (!state.done)
+                state.finalRejecter(error);
+            state.done = true;
+        }
+    }
+    function settleState(id, state) {
+        if (state.done)
+            return undefined;
+        const handlers = handlersById.get(id) ?? emptyHandlers;
+        const { final, error, cancelled } = buildFinalFromEvents(state.allEvents, handlers);
+        if (error) {
+            const err = new CompletionFailedError(error.message, error);
+            state.finalRejecter(err);
+            state.done = true;
+            return err;
+        }
+        if (cancelled) {
+            const err = new InferenceCancelledError(requestId, {
+                text: final.contentText,
+                toolCalls: final.toolCalls,
+                ...(final.stats && { stats: final.stats })
+            });
+            state.finalRejecter(err);
+            state.done = true;
+            return err;
+        }
+        state.finalResolver(final);
+        state.done = true;
+        return { id, final };
+    }
+    function finishAll(ids) {
+        const results = [];
+        let firstError;
+        settledIds = new Set(ids);
+        for (const id of ids) {
+            const state = ensureState(id);
+            const outcome = settleState(id, state);
+            if (outcome instanceof Error) {
+                firstError ??= outcome;
+            }
+            else if (outcome !== undefined) {
+                results.push(outcome);
+            }
+        }
+        for (const [id, state] of states) {
+            if (!settledIds.has(id) && !state.done) {
+                state.finalRejecter(new CompletionFailedError(`Unknown batch prompt id "${id}".`));
+                state.done = true;
+            }
+        }
+        if (firstError !== undefined) {
+            resultsRejecter(firstError);
+        }
+        else {
+            resultsResolver(results);
+        }
+        return firstError;
+    }
+    const processResponses = async () => {
+        try {
+            const resolved = await resolveBatchPrompts(params.prompts);
+            handlersByPosition = resolved.handlers;
+            const request = {
+                type: 'batchCompletionStream',
+                modelId: params.modelId,
+                prompts: resolved.prompts,
+                stream: params.stream ?? true,
+                captureThinking: params.captureThinking,
+                emitRawDeltas: params.emitRawDeltas,
+                toolDialect: params.toolDialect,
+                requestId
+            };
+            let orderedIds = [];
+            const responses = streamFactory(request, params.rpcOptions);
+            for await (const response of responses) {
+                if (response &&
+                    typeof response === 'object' &&
+                    'type' in response &&
+                    response.type === 'batchCompletionStream') {
+                    const streamResponse = batchCompletionStreamResponseSchema.parse(response);
+                    if (streamResponse.ids) {
+                        orderedIds = streamResponse.ids;
+                        resolveIds(orderedIds);
+                    }
+                    for (const batchEvent of streamResponse.events) {
+                        const state = ensureState(batchEvent.id);
+                        state.allEvents.push(batchEvent.event);
+                        eventQueue.push(batchEvent);
+                    }
+                    notifyWaiters();
+                    if (streamResponse.done) {
+                        if (!idsResolved) {
+                            orderedIds =
+                                orderedIds.length > 0
+                                    ? orderedIds
+                                    : params.prompts.map((prompt, index) => prompt.id ?? String(index));
+                            resolveIds(orderedIds);
+                        }
+                        const firstError = finishAll(orderedIds);
+                        if (firstError !== undefined) {
+                            statsRejecter(firstError);
+                        }
+                        else {
+                            statsResolver(streamResponse.stats);
+                        }
+                        done = true;
+                        notifyWaiters();
+                    }
+                }
+            }
+        }
+        catch (error) {
+            streamError = error instanceof Error ? error : new Error(String(error));
+            rejectAll(error);
+            done = true;
+            for (const state of states.values())
+                state.done = true;
+            notifyWaiters();
+        }
+    };
+    void processResponses();
+    const events = (async function* () {
+        while (true) {
+            if (eventQueue.length > 0) {
+                yield eventQueue.shift();
+            }
+            else if (done) {
+                if (streamError !== null) {
+                    throw streamError;
+                }
+                break;
+            }
+            else {
+                await new Promise((resolve) => {
+                    eventResolve = resolve;
+                });
+            }
+        }
+    })();
+    function makeSubStream(id) {
+        const state = ensureState(id);
+        const events = {
+            async *[Symbol.asyncIterator]() {
+                let index = 0;
+                while (true) {
+                    if (index < state.allEvents.length) {
+                        yield state.allEvents[index];
+                        index += 1;
+                    }
+                    else if (state.done || done) {
+                        if (streamError !== null) {
+                            throw streamError;
+                        }
+                        break;
+                    }
+                    else {
+                        await new Promise((resolve) => {
+                            state.eventWaiters.push(resolve);
+                        });
+                    }
+                }
+            }
+        };
+        return {
+            events,
+            final: state.final
+        };
+    }
+    function byId(id) {
+        let subStream = subStreams.get(id);
+        if (!subStream) {
+            subStream = makeSubStream(id);
+            subStreams.set(id, subStream);
+        }
+        return subStream;
+    }
+    return {
+        requestId,
+        ids: idsPromise,
+        events,
+        results: resultsPromise,
+        stats: statsPromise,
+        byId
+    };
+}

package/dist/client/api/bci-transcribe.d.ts

@@ -1,4 +1,4 @@
-import { type BciTranscribeClientParams, type BciTranscribeStreamClientParams, type BciTranscribeStreamSession, type BciTranscribeStreamMetadataSession, type RPCOptions, type TranscribeSegment } from "../../schemas/index";
+import { type BciTranscribeClientParams, type BciTranscribeStreamClientParams, type BciTranscribeStreamSession, type BciTranscribeStreamMetadataSession, type RPCOptions, type TranscribeSegment } from '../../schemas/index';
 /**
  * Transcribe a neural-signal buffer with a loaded BCI model and return the
  * complete text. Accepts either a `.bin` file path or a raw neural buffer.