@qvac/sdk 0.20.1 → 0.21.0

package/dist/scripts/generate-bare-kit-runtimes.js

@@ -0,0 +1,106 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import semver from 'semver';
+import { fetchBareKitVersionFromGitHub, fetchBareVersionFromGitHub, fetchText, REACT_NATIVE_BARE_KIT } from '../src/commands/verify/bare-kit-runtime.js';
+import { BARE_KIT_BARE_VERSIONS, REACT_NATIVE_BARE_KIT_RUNTIMES } from '../src/commands/verify/bare-kit-runtimes.js';
+const CONCURRENCY = 8;
+const OUTPUT_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'src', 'commands', 'verify', 'bare-kit-runtimes.ts');
+async function listPublishedVersions() {
+    const metadata = JSON.parse(await fetchText(`https://registry.npmjs.org/${REACT_NATIVE_BARE_KIT}`));
+    return Object.keys(metadata.versions);
+}
+async function listBareKitTags() {
+    const tags = JSON.parse(await fetchText('https://api.github.com/repos/holepunchto/bare-kit/tags?per_page=100'));
+    return tags.map((tag) => tag.name.replace(/^v/, ''));
+}
+function latest(versions) {
+    const valid = versions.filter((version) => semver.valid(version) !== null);
+    return valid.length === 0 ? null : valid.sort(semver.rcompare)[0];
+}
+/**
+ * Releases newer than the newest one already in the table, oldest first.
+ * Everything at or below it was probed on an earlier run, including the old
+ * react-native-bare-kit releases that have no CMakeLists.txt to parse.
+ */
+function newerThan(versions, lastKnown) {
+    return versions
+        .filter((version) => semver.valid(version) !== null)
+        .filter((version) => lastKnown === null || semver.gt(version, lastKnown))
+        .sort(semver.compare);
+}
+async function mapConcurrent(items, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await fn(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: CONCURRENCY }, worker));
+    return results;
+}
+async function tryFetch(fn) {
+    try {
+        return await fn();
+    }
+    catch {
+        return null;
+    }
+}
+function sortedEntries(record) {
+    return Object.entries(record).sort(([a], [b]) => semver.compare(a, b));
+}
+function render(runtimes, bareByBareKit) {
+    const lines = [
+        '// Generated by scripts/generate-bare-kit-runtimes.ts. Do not edit by hand.',
+        '',
+        'export interface BareKitRuntime {',
+        '  bareKit: string',
+        '  bare: string',
+        '}',
+        '',
+        '/**',
+        ' * react-native-bare-kit releases whose CMakeLists.txt names the bare-kit',
+        ' * prebuilds it ships. Older releases carry no such reference.',
+        ' */',
+        'export const REACT_NATIVE_BARE_KIT_RUNTIMES: Record<string, BareKitRuntime> = {'
+    ];
+    lines.push(...entryLines(sortedEntries(runtimes).map(([version, runtime]) => `'${version}': { bareKit: '${runtime.bareKit}', bare: '${runtime.bare}' }`)));
+    lines.push('}', '', '/** Bare version each bare-kit release is built against. */');
+    lines.push('export const BARE_KIT_BARE_VERSIONS: Record<string, string> = {');
+    lines.push(...entryLines(sortedEntries(bareByBareKit).map(([bareKit, bare]) => `'${bareKit}': '${bare}'`)));
+    lines.push('}', '');
+    return lines.join('\n');
+}
+/** Object entries in the repo's Prettier style: no trailing comma. */
+function entryLines(entries) {
+    return entries.map((entry, index) => `  ${entry}${index === entries.length - 1 ? '' : ','}`);
+}
+async function main() {
+    const full = process.argv.includes('--full');
+    const bareByBareKit = full ? {} : { ...BARE_KIT_BARE_VERSIONS };
+    const runtimes = full ? {} : { ...REACT_NATIVE_BARE_KIT_RUNTIMES };
+    const bareKitTags = newerThan(await listBareKitTags(), latest(Object.keys(bareByBareKit)));
+    console.log(`Resolving ${bareKitTags.length} new bare-kit releases...`);
+    const bareVersions = await mapConcurrent(bareKitTags, (bareKit) => tryFetch(() => fetchBareVersionFromGitHub(bareKit)));
+    bareKitTags.forEach((bareKit, index) => {
+        const bare = bareVersions[index];
+        if (bare)
+            bareByBareKit[bareKit] = bare;
+    });
+    const versions = newerThan(await listPublishedVersions(), latest(Object.keys(runtimes)));
+    console.log(`Resolving ${versions.length} new ${REACT_NATIVE_BARE_KIT} releases...`);
+    const bareKitByVersion = await mapConcurrent(versions, (version) => tryFetch(() => fetchBareKitVersionFromGitHub(version)));
+    versions.forEach((version, index) => {
+        const bareKit = bareKitByVersion[index];
+        const bare = bareKit ? bareByBareKit[bareKit] : undefined;
+        if (bareKit && bare)
+            runtimes[version] = { bareKit, bare };
+    });
+    await fsp.writeFile(OUTPUT_PATH, render(runtimes, bareByBareKit));
+    console.log(`Wrote ${Object.keys(runtimes).length} ${REACT_NATIVE_BARE_KIT} and ` +
+        `${Object.keys(bareByBareKit).length} bare-kit entries to ${OUTPUT_PATH}`);
+}
+await main();

package/dist/src/client/api/assess-model-fit.d.ts

@@ -9,11 +9,12 @@ import { type AssessModelFitInput, type AssessModelFitResult } from '@qvac/infer
  * should treat it as "cannot say", not "no".
  *
  * For a single candidate it fetches the registry's weightless description of
- * the artifact — tens of KB, never the weights — and runs the engine's own
- * fitter against it, reported as `native-fit` evidence. Where that is
- * unavailable, and for a set of candidates, the calibrated estimate stands.
+ * every source that load names — tens of KB each, never the weights — and runs
+ * the engine's own fitter against them, reported as `native-fit` evidence.
+ * Where that is unavailable, and for a set of candidates, the calibrated
+ * estimate stands.
  *
- * @param input - Candidates with their intended workloads, the declared
+ * @param input - Loads to assess in `loadModel`'s own parameters, the declared
  *   execution mode, and the headroom policy.
  * @returns Per-model and combined verdicts, with the budget and bounds they came
  *   from, plus every assumption that was made.

package/dist/src/client/api/assess-model-fit.js

@@ -1,6 +1,19 @@
-import { assessModelFitInputSchema } from '@qvac/inference/surface';
+import { assessModelFitInputSchema, inferModelTypeFromModelSrc } from '@qvac/inference/surface';
 import { send } from '../rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
+import { InvalidResponseError, ModelTypeRequiredError } from '../../utils/errors-client.js';
+/**
+ * Names the engine a candidate omitted, from the source it carries.
+ *
+ * @throws {ModelTypeRequiredError} When the source names no engine either.
+ */
+function withModelType(candidate) {
+    if (candidate.modelType !== undefined)
+        return candidate;
+    const inferred = inferModelTypeFromModelSrc(candidate.modelSrc);
+    if (inferred === undefined)
+        throw new ModelTypeRequiredError();
+    return { ...candidate, modelType: inferred };
+}
 /**
  * Assesses, before anything is downloaded, whether the given models are likely
  * to fit in this device's memory.
@@ -11,17 +24,21 @@ import { InvalidResponseError } from '../../utils/errors-client.js';
  * should treat it as "cannot say", not "no".
  *
  * For a single candidate it fetches the registry's weightless description of
- * the artifact — tens of KB, never the weights — and runs the engine's own
- * fitter against it, reported as `native-fit` evidence. Where that is
- * unavailable, and for a set of candidates, the calibrated estimate stands.
+ * every source that load names — tens of KB each, never the weights — and runs
+ * the engine's own fitter against them, reported as `native-fit` evidence.
+ * Where that is unavailable, and for a set of candidates, the calibrated
+ * estimate stands.
  *
- * @param input - Candidates with their intended workloads, the declared
+ * @param input - Loads to assess in `loadModel`'s own parameters, the declared
  *   execution mode, and the headroom policy.
  * @returns Per-model and combined verdicts, with the budget and bounds they came
  *   from, plus every assumption that was made.
  */
 export async function assessModelFit(input) {
-    const parsed = assessModelFitInputSchema.parse(input);
+    const parsed = assessModelFitInputSchema.parse({
+        ...input,
+        models: input.models.map(withModelType)
+    });
     const request = { type: 'assessModelFit', ...parsed };
     const response = await send(request);
     if (response.type !== 'assessModelFit') {

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

@@ -37,7 +37,10 @@ export declare function bciTranscribe(params: BciTranscribeClientParams, options
  * @param params.modelId - The loaded BCI model to use.
  * @param params.metadata - When true, the session yields transcript segment
  *                          objects (`{ text, startMs, endMs, append, id }`)
- *                          instead of plain text.
+ *                          instead of plain text. With `emit: 'delta'`, each
+ *                          segment also carries `windowStartTimestep`: its
+ *                          timestamps are window-local, and this maps them
+ *                          onto the stream timeline.
  * @param params.windowTimesteps - Decode window size in timesteps.
  * @param params.hopTimesteps - How far the window advances between decodes.
  * @param params.emit - `'delta'` (default) yields only the newly-discovered

package/dist/src/client/api/get-system-resources.d.ts

@@ -1,3 +1,11 @@
 import { type GetSystemResourcesInput, type SystemResources } from '@qvac/inference/surface';
+/**
+ * Read the worker's system capabilities and optional resource sample.
+ *
+ * @param input - Optional settings; set `sample` to request a current resource sample.
+ * @returns System capabilities with availability information and a sample when provided by the worker.
+ * @throws {InvalidResponseError} If the worker returns a different response type.
+ * @throws {Error} If the RPC request fails.
+ */
 export declare function getSystemResources(input?: GetSystemResourcesInput): Promise<SystemResources>;
 //# sourceMappingURL=get-system-resources.d.ts.map

package/dist/src/client/api/get-system-resources.js

@@ -1,6 +1,14 @@
 import {} from '@qvac/inference/surface';
 import { send } from '../rpc/rpc-client.js';
 import { InvalidResponseError } from '../../utils/errors-client.js';
+/**
+ * Read the worker's system capabilities and optional resource sample.
+ *
+ * @param input - Optional settings; set `sample` to request a current resource sample.
+ * @returns System capabilities with availability information and a sample when provided by the worker.
+ * @throws {InvalidResponseError} If the worker returns a different response type.
+ * @throws {Error} If the RPC request fails.
+ */
 export async function getSystemResources(input) {
     const request = {
         type: 'getSystemResources',

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

@@ -37,4 +37,5 @@ export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-h
 export { audioGen } from './audio-gen.js';
 export { audioEdit } from './audio-edit.js';
 export { audioUnderstand } from './audio-understand.js';
+export { startRpcServer, stopRpcServer, discoverRpcServers } from './rpc-server.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/client/api/index.js

@@ -37,3 +37,4 @@ export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-h
 export { audioGen } from './audio-gen.js';
 export { audioEdit } from './audio-edit.js';
 export { audioUnderstand } from './audio-understand.js';
+export { startRpcServer, stopRpcServer, discoverRpcServers } from './rpc-server.js';

package/dist/src/client/api/rpc-server.d.ts

@@ -0,0 +1,20 @@
+import { type StartRpcServerOptions, type StopRpcServerOptions, type DiscoverRpcServersOptions, type RpcServerInfo, type RpcServerCandidate } from '@qvac/inference/surface';
+/**
+ * Start a worker-owned native RPC server. Non-loopback binding and advertising require explicit opt-in.
+ * Cancel a pending start with its promise.requestId.
+ */
+export declare function startRpcServer(options?: StartRpcServerOptions): Promise<RpcServerInfo> & {
+    requestId: string;
+};
+/** Withdraw the announcement and await native stop. Bare stop has no deadline. */
+export declare function stopRpcServer(options: StopRpcServerOptions): Promise<void>;
+/**
+ * Find private-network candidates with device inventories and server RDMA availability.
+ * RDMA availability is a server-side offer, not a guarantee of the negotiated transport.
+ * Use getRpcDeviceMap with the chosen endpoint registration order before loadModel.
+ * Cancel a pending search with its promise.requestId.
+ */
+export declare function discoverRpcServers(options: DiscoverRpcServersOptions): Promise<RpcServerCandidate[]> & {
+    requestId: string;
+};
+//# sourceMappingURL=rpc-server.d.ts.map

package/dist/src/client/api/rpc-server.js

@@ -0,0 +1,45 @@
+import {} from '@qvac/inference/surface';
+import { send } from '../rpc/rpc-client.js';
+import { InvalidResponseError } from '../../utils/errors-client.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { generateClientRequestId } from './client-request-id.js';
+/**
+ * Start a worker-owned native RPC server. Non-loopback binding and advertising require explicit opt-in.
+ * Cancel a pending start with its promise.requestId.
+ */
+export function startRpcServer(options = {}) {
+    const requestId = generateClientRequestId();
+    return decoratePromise(runStartRpcServer(options, requestId), { requestId });
+}
+async function runStartRpcServer(options, requestId) {
+    const response = await send({ ...options, type: 'startRpcServer', requestId });
+    if (response.type !== 'startRpcServer')
+        throw new InvalidResponseError('startRpcServer');
+    return {
+        serverId: response.serverId,
+        url: response.url,
+        rdmaCapable: response.rdmaCapable
+    };
+}
+/** Withdraw the announcement and await native stop. Bare stop has no deadline. */
+export async function stopRpcServer(options) {
+    const response = await send({ ...options, type: 'stopRpcServer' });
+    if (response.type !== 'stopRpcServer')
+        throw new InvalidResponseError('stopRpcServer');
+}
+/**
+ * Find private-network candidates with device inventories and server RDMA availability.
+ * RDMA availability is a server-side offer, not a guarantee of the negotiated transport.
+ * Use getRpcDeviceMap with the chosen endpoint registration order before loadModel.
+ * Cancel a pending search with its promise.requestId.
+ */
+export function discoverRpcServers(options) {
+    const requestId = generateClientRequestId();
+    return decoratePromise(runDiscoverRpcServers(options, requestId), { requestId });
+}
+async function runDiscoverRpcServers(options, requestId) {
+    const response = await send({ ...options, type: 'discoverRpcServers', requestId });
+    if (response.type !== 'discoverRpcServers')
+        throw new InvalidResponseError('discoverRpcServers');
+    return response.servers;
+}

package/dist/src/client/api/text-to-speech.d.ts

@@ -43,6 +43,15 @@ export declare class TtsMulticast {
  *   metadata with the audio. Multiple consumers can iterate the response
  *   independently via the underlying `TtsMulticast`.
  *
+ * MOSS models stream natively rather than by sentence: under `stream: true`
+ * the whole text is one synthesis whose audio arrives every
+ * `streamChunkTokens` codec frames (in one piece when that is unset), so
+ * `durationTokens` and a MOSS-TTSD dialogue's reference transcripts apply to
+ * the text as a whole. `sentenceStream: true` still splits a single-speaker
+ * text; a dialogue rejects it. `sentenceStreamLocale` and
+ * `sentenceStreamMaxChunkScalars` configure that splitting, so a MOSS request
+ * rejects them unless it sets `sentenceStream: true`.
+ *
  * `result.done` resolves to `true` when synthesis completes cleanly, `false`
  * if the consumer breaks out before the terminal frame, or rejects on a
  * pipeline error. Awaiting `done` is safe even when no stream is iterated.

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

@@ -202,6 +202,15 @@ function buildTextToSpeechStreamRequest(params, requestId) {
  *   metadata with the audio. Multiple consumers can iterate the response
  *   independently via the underlying `TtsMulticast`.
  *
+ * MOSS models stream natively rather than by sentence: under `stream: true`
+ * the whole text is one synthesis whose audio arrives every
+ * `streamChunkTokens` codec frames (in one piece when that is unset), so
+ * `durationTokens` and a MOSS-TTSD dialogue's reference transcripts apply to
+ * the text as a whole. `sentenceStream: true` still splits a single-speaker
+ * text; a dialogue rejects it. `sentenceStreamLocale` and
+ * `sentenceStreamMaxChunkScalars` configure that splitting, so a MOSS request
+ * rejects them unless it sets `sentenceStream: true`.
+ *
  * `result.done` resolves to `true` when synthesis completes cleanly, `false`
  * if the consumer breaks out before the terminal frame, or rejects on a
  * pipeline error. Awaiting `done` is safe even when no stream is iterated.

package/dist/src/client/api/transcribe.d.ts

@@ -1,5 +1,5 @@
-import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, type TranscribeStreamRequest, type TranscribeStreamClientParams, type TranscribeStreamSession, type TranscribeStreamMetadataSession, type TranscribeStreamConversationSession, type TranscribeStats } from '@qvac/inference/surface';
-import { duplex } from '../rpc/rpc-client.js';
+import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, type TranscribeStreamRequest, type TranscribeStreamClientParams, type TranscribeStreamSession, type TranscribeStreamMetadataSession, type TranscribeStreamConversationSession, type TranscribeStreamEvent, type TranscribeStats, type InferenceBackendDiagnostics } from '@qvac/inference/surface';
+import { stream, duplex } from '../rpc/rpc-client.js';
 type TranscribeDuplexFactory = (request: TranscribeStreamRequest, options?: RPCOptions) => ReturnType<typeof duplex>;
 /**
  * Transcribe audio and return the complete text. Accepts either a file
@@ -10,24 +10,27 @@ type TranscribeDuplexFactory = (request: TranscribeStreamRequest, options?: RPCO
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
  * @param params.prompt - Optional initial prompt to guide the transcription
  * @param params.metadata - When true, resolves to an array of transcript
- *                          segments (`{ text, startMs, endMs, append, id }`)
- *                          instead of joined text. Whisper engine only.
+ *                          segments (`{ text, startMs, endMs, append, id }`,
+ *                          plus `isEndOfTurn` and `startsWord` on parakeet)
+ *                          instead of joined text.
  * @param options - Optional RPC options including per-call profiling
  * @returns A promise (decorated with `requestId`) resolving to the
  *          complete transcribed text, or — when `metadata` is true —
  *          the list of transcript segments in emission order. The
  *          `requestId` is reachable synchronously so callers can target
  *          this in-flight transcription with `cancel({ requestId })`
- *          before `await` resolves.
+ *          before `await` resolves. `stats` resolves to the terminal engine
+ *          statistics, including Parakeet's per-run Core ML usage.
  */
-export declare function transcribe(params: TranscribeClientParams & {
-    metadata: true;
-}, options?: RPCOptions): Promise<TranscribeSegment[]> & {
-    requestId: string;
-};
-export declare function transcribe(params: TranscribeClientParams, options?: RPCOptions): Promise<string> & {
+type TranscribeCall<T> = Promise<T> & {
     requestId: string;
+    stats: Promise<TranscribeStats | undefined>;
 };
+export declare function transcribe(params: TranscribeClientParams & {
+    metadata: true;
+}, options?: RPCOptions): TranscribeCall<TranscribeSegment[]>;
+export declare function transcribe(params: TranscribeClientParams, options?: RPCOptions): TranscribeCall<string>;
+export declare function createTranscribeCall(params: TranscribeClientParams, options?: RPCOptions, responseStream?: typeof stream): TranscribeCall<string | TranscribeSegment[]>;
 /**
  * @deprecated Pass audio via `transcribe()` instead. This overload will be
  * removed in the next major version.
@@ -57,8 +60,9 @@ export declare function transcribeStream(params: TranscribeClientParams, options
  * @param params.modelId - The loaded transcription model to use
  * @param params.prompt - Optional initial prompt to guide transcription
  * @param params.metadata - When true, the session yields transcript segment
- *                          objects (`{ text, startMs, endMs, append, id }`)
- *                          instead of plain text. Whisper engine only.
+ *                          objects (`{ text, startMs, endMs, append, id }`,
+ *                          plus `isEndOfTurn` and `startsWord` on parakeet)
+ *                          instead of plain text.
  * @param options - Optional RPC options including per-call profiling.
  * @returns A session object: call `write(audioChunk)` with a `Uint8Array`
  *          (Node `Buffer` is a `Uint8Array` subtype) to feed audio,
@@ -81,13 +85,15 @@ export declare function transcribeStream(params: TranscribeStreamClientParams, o
  * to surface strings or segments; `sessionName` is only used to label the
  * "already iterated" error so callers see the correct session type.
  */
-export declare function createTranscribeStreamSession<T>(params: TranscribeStreamClientParams, options: RPCOptions | undefined, process: (line: string, onStats: (stats: TranscribeStats | undefined) => void) => T | undefined | null, sessionName: string, duplexFactory?: TranscribeDuplexFactory): Promise<{
+export declare function createTranscribeStreamSession<T>(params: TranscribeStreamClientParams, options: RPCOptions | undefined, process: (line: string, onTerminal: (stats: TranscribeStats | undefined, diagnostics: InferenceBackendDiagnostics | undefined) => void) => T | undefined | null, sessionName: string, duplexFactory?: TranscribeDuplexFactory): Promise<{
     stats: Promise<TranscribeStats | undefined>;
+    diagnostics: Promise<InferenceBackendDiagnostics | undefined>;
     write(audioChunk: Uint8Array): void;
     end(): void;
     destroy(): void;
     [Symbol.asyncIterator](): AsyncIterator<T>;
 }>;
-export declare function processLine(line: string, onStats: (stats: TranscribeStats | undefined) => void): string | undefined | null;
+export declare function processLine(line: string, onTerminal: (stats: TranscribeStats | undefined, diagnostics: InferenceBackendDiagnostics | undefined) => void): string | undefined | null;
+export declare function processLineConversation(line: string, wantsMetadata: boolean, onTerminal: (stats: TranscribeStats | undefined, diagnostics: InferenceBackendDiagnostics | undefined) => void): TranscribeStreamEvent | undefined | null;
 export {};
 //# sourceMappingURL=transcribe.d.ts.map

package/dist/src/client/api/transcribe.js

@@ -18,26 +18,38 @@ function buildTranscribeRequest(params, requestId) {
     };
 }
 export function transcribe(params, options) {
+    return createTranscribeCall(params, options);
+}
+export function createTranscribeCall(params, options, responseStream = stream) {
     // Client-generated id surfaced synchronously on the returned promise
     // — same shape as `loadModel` / `downloadAsset` / `completion`. The
     // CLI cancel bridge in `qvac serve` binds `req.on('close')` to
     // `cancel({ requestId })` immediately after the call returns so a
     // client disconnect aborts the in-flight transcription.
     const requestId = generateClientRequestId();
-    const inner = runTranscribe(params, requestId, options);
-    return decoratePromise(inner, { requestId });
+    let resolveStats = () => { };
+    let rejectStats = () => { };
+    const stats = new Promise((resolve, reject) => {
+        resolveStats = resolve;
+        rejectStats = reject;
+    });
+    stats.catch(() => { });
+    const inner = runTranscribe(params, requestId, options, resolveStats, responseStream);
+    inner.then(() => resolveStats(undefined), rejectStats);
+    return decoratePromise(inner, { requestId, stats });
 }
-async function runTranscribe(params, requestId, options) {
+async function runTranscribe(params, requestId, options, onStats, responseStream) {
     const request = buildTranscribeRequest(params, requestId);
     if (params.metadata === true) {
         const segments = [];
-        for await (const response of stream(request, options)) {
+        for await (const response of responseStream(request, options)) {
             if (response.type === 'transcribe') {
                 const parsed = transcribeResponseSchema.parse(response);
                 if (parsed.segment) {
                     segments.push(parsed.segment);
                 }
                 if (parsed.done) {
+                    onStats(parsed.stats);
                     break;
                 }
             }
@@ -45,13 +57,14 @@ async function runTranscribe(params, requestId, options) {
         return segments;
     }
     let fullText = '';
-    for await (const response of stream(request, options)) {
+    for await (const response of responseStream(request, options)) {
         if (response.type === 'transcribe') {
             const parsed = transcribeResponseSchema.parse(response);
             if (parsed.text) {
                 fullText += parsed.text;
             }
             if (parsed.done) {
+                onStats(parsed.stats);
                 break;
             }
         }
@@ -144,16 +157,47 @@ export async function createTranscribeStreamSession(params, options, process, se
         statsSettled = true;
         rejectStatsPromise(error);
     }
-    function resolveEmptyStats() {
-        resolveStats(undefined);
+    // Settled from the same terminal frame as `stats`, and on the same paths:
+    // resolved empty when the stream closes without one, rejected on error.
+    let diagnosticsSettled = false;
+    let resolveDiagnosticsPromise = () => { };
+    let rejectDiagnosticsPromise = () => { };
+    const diagnostics = new Promise((resolve, reject) => {
+        resolveDiagnosticsPromise = resolve;
+        rejectDiagnosticsPromise = reject;
+    });
+    diagnostics.catch(() => { });
+    function resolveDiagnostics(value) {
+        if (diagnosticsSettled)
+            return;
+        diagnosticsSettled = true;
+        resolveDiagnosticsPromise(value);
+    }
+    function rejectDiagnostics(error) {
+        if (diagnosticsSettled)
+            return;
+        diagnosticsSettled = true;
+        rejectDiagnosticsPromise(error);
+    }
+    function resolveTerminal(statsValue, diagnosticsValue) {
+        resolveStats(statsValue);
+        resolveDiagnostics(diagnosticsValue);
+    }
+    function resolveEmptyTerminal() {
+        resolveTerminal(undefined, undefined);
+    }
+    function rejectTerminal(error) {
+        rejectStats(error);
+        rejectDiagnostics(error);
     }
     function processResponse(line) {
-        return process(line, resolveStats);
+        return process(line, resolveTerminal);
     }
-    const responses = parseLines(responseStream, processResponse, resolveEmptyStats, rejectStats);
+    const responses = parseLines(responseStream, processResponse, resolveEmptyTerminal, rejectTerminal);
     let consumed = false;
     return {
         stats,
+        diagnostics,
         write(audioChunk) {
             requestStream.write(audioChunk);
         },
@@ -161,7 +205,7 @@ export async function createTranscribeStreamSession(params, options, process, se
             requestStream.end();
         },
         destroy() {
-            resolveStats(undefined);
+            resolveEmptyTerminal();
             requestStream.destroy();
             responseStream.destroy();
         },
@@ -182,7 +226,7 @@ function transcribeStreamDuplexMetadata(params, options) {
 }
 function transcribeStreamDuplexConversation(params, options) {
     const wantsMetadata = params.metadata === true;
-    return createTranscribeStreamSession(params, options, (line, onStats) => processLineConversation(line, wantsMetadata, onStats), 'TranscribeStreamConversationSession');
+    return createTranscribeStreamSession(params, options, (line, onTerminal) => processLineConversation(line, wantsMetadata, onTerminal), 'TranscribeStreamConversationSession');
 }
 /**
  * Line-delimited parser: reads newline-separated frames from a duplex
@@ -241,31 +285,32 @@ function parseResponseLine(line) {
  * `undefined` for frames the caller should skip, or the value extracted from
  * the frame.
  */
-function processWith(line, extract, onStats) {
+function processWith(line, extract, onTerminal) {
     const response = parseResponseLine(line);
     if (response === null)
         return undefined;
     if (response.error)
         throw new TranscriptionFailedError(response.error);
     if (response.done) {
-        onStats(response.stats);
+        onTerminal(response.stats, response.diagnostics);
         return null;
     }
     return extract(response);
 }
-export function processLine(line, onStats) {
-    return processWith(line, (response) => (response.text?.trim() ? response.text : undefined), onStats);
+export function processLine(line, onTerminal) {
+    return processWith(line, (response) => (response.text?.trim() ? response.text : undefined), onTerminal);
 }
-function processLineMetadata(line, onStats) {
-    return processWith(line, (response) => response.segment, onStats);
+function processLineMetadata(line, onTerminal) {
+    return processWith(line, (response) => response.segment, onTerminal);
 }
-function processLineConversation(line, wantsMetadata, onStats) {
+export function processLineConversation(line, wantsMetadata, onTerminal) {
     return processWith(line, (response) => {
         if (response.vad) {
             return {
                 type: 'vad',
                 speaking: response.vad.speaking,
-                probability: response.vad.probability
+                probability: response.vad.probability,
+                ...(response.vad.source && { source: response.vad.source })
             };
         }
         if (response.endOfTurn) {
@@ -291,5 +336,5 @@ function processLineConversation(line, wantsMetadata, onStats) {
             return { type: 'text', text: response.text };
         }
         return undefined;
-    }, onStats);
+    }, onTerminal);
 }

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

@@ -1,4 +1,4 @@
-import { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, TranslationFailedError } from '../../utils/errors-server.js';
+import { RpcServerOperationError, InferenceCancelledError, ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, TranslationFailedError } from '../../utils/errors-server.js';
 export class RPCError extends Error {
     timestamp;
     remoteStack;
@@ -93,14 +93,18 @@ function readOptionalStringField(fields, key) {
  * be re-exported from `@qvac/sdk` so consumers can `import` it.
  * Forgetting either side means `instanceof` regresses for that class.
  *
- * Client-constructed typed errors (e.g. `InferenceCancelledError`
- * built in `client/api/completion-stream.ts` from the aggregated
- * partial state) are NOT registered here — they never round-trip the
- * envelope, and adding a reconstructor for one would create a
- * parallel construction path that fires whenever the server happens
- * to throw the same class name.
+ * Completion aggregators construct cancellation errors locally with partial
+ * output. RPC control operations also throw them in the worker, so cancellation
+ * errors support both paths.
  */
 const RECONSTRUCTORS = {
+    INFERENCE_CANCELLED: (response) => {
+        const partial = response.typedFields?.['partial'];
+        return new InferenceCancelledError(readStringField(response.typedFields, 'requestId', ''), partial && typeof partial === 'object' && !Array.isArray(partial)
+            ? partial
+            : {}, response.cause);
+    },
+    RPC_SERVER_OPERATION_FAILED: (response) => new RpcServerOperationError(readStringField(response.typedFields, 'operation', 'rpcServer'), readStringField(response.typedFields, 'details', response.message), response.cause),
     REQUEST_ID_CONFLICT: (response) => {
         return new RequestIdConflictError(readStringField(response.typedFields, 'requestId', ''), response.cause);
     },

package/dist/src/commands/bundle/entry-gen.d.ts

@@ -1,5 +1,5 @@
-export declare function generateWorkerEntry(pluginSpecifiers: string[], sdkName: string, resolveImport?: (specifier: string) => string): string;
-export declare function generateWorkerEntries(pluginSpecifiers: string[], sdkName: string, resolveBundleImport: (specifier: string) => string): {
+export declare function generateWorkerEntry(pluginSpecifiers: string[], sdkName: string, resolveImport?: (specifier: string) => string, rpcServerProvider?: string): string;
+export declare function generateWorkerEntries(pluginSpecifiers: string[], sdkName: string, resolveBundleImport: (specifier: string) => string, rpcServerProvider?: string): {
     runtimeEntry: string;
     bundleEntry: string;
 };