@qvac/sdk 0.19.0 → 0.20.0

package/dist/src/client/api/audio-edit.js

@@ -0,0 +1,38 @@
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { createAudioEditResult } from './audio-gen-result.js';
+/**
+ * Edits a source recording with a loaded ACE-Step AudioGen model: an ordered
+ * pipeline of `flow-edit` and `repaint` operations, executed in array order.
+ *
+ * @param params - Loaded model ID, the source audio, the ordered `operations`, and an optional `seed`.
+ * @param params.sourceAudio - The recording to edit: a file path (decoded server-side) or raw
+ *   interleaved stereo 48 kHz Float32 LE PCM bytes in `[-1, 1]`.
+ * @param params.operations - `flow-edit` re-conditions the whole clip from a `from` prompt to a
+ *   `to` prompt over an optional `nMin`/`nMax` diffusion window (turbo DiT variants only);
+ *   `repaint` regenerates the `start`..`end` range (seconds) against a new `caption`, keeping the
+ *   rest of the clip. Operations may repeat or mix.
+ * @param params.seed - Seeds the first operation; each following operation uses `seed + index`.
+ * @returns The same run shape as `audioGen()`: a synchronous request ID, generation progress stream, PCM audio promise, stats promise, and diagnostics promise.
+ *
+ * @example
+ * ```typescript
+ * const run = audioEdit({
+ *   modelId,
+ *   sourceAudio: "/path/to/song.wav",
+ *   operations: [
+ *     {
+ *       type: "flow-edit",
+ *       from: { caption: "original pop song", lyrics: originalLyrics },
+ *       to: { caption: "guitar pop-rock", lyrics: newLyrics },
+ *     },
+ *     { type: "repaint", caption: "analog synth solo", start: 10, end: 20, mode: "balanced" },
+ *   ],
+ *   seed: 22883,
+ * });
+ * stopButton.onclick = () => cancel({ requestId: run.requestId });
+ * const { pcm, sampleRate, channels, bitsPerSample } = await run.audio;
+ * ```
+ */
+export function audioEdit(params) {
+    return createAudioEditResult(params, streamRpc);
+}

package/dist/src/client/api/audio-gen-result.d.ts

@@ -1,4 +1,8 @@
-import { type AudioGenClientParams, type AudioGenResult, type AudioGenStreamRequest } from '@qvac/inference/surface';
+import { type AudioEditClientParams, type AudioEditStreamRequest, type AudioGenClientParams, type AudioGenResult, type AudioGenStreamRequest, type AudioUnderstandClientParams, type AudioUnderstandRequest, type AudioUnderstandResult } from '@qvac/inference/surface';
 export type AudioGenStreamFactory = (request: AudioGenStreamRequest) => AsyncGenerator<unknown>;
+export type AudioEditStreamFactory = (request: AudioEditStreamRequest) => AsyncGenerator<unknown>;
+export type AudioUnderstandStreamFactory = (request: AudioUnderstandRequest) => AsyncGenerator<unknown>;
 export declare function createAudioGenResult(params: AudioGenClientParams, streamFactory: AudioGenStreamFactory): AudioGenResult;
+export declare function createAudioEditResult(params: AudioEditClientParams, streamFactory: AudioEditStreamFactory): AudioGenResult;
+export declare function createAudioUnderstandResult(params: AudioUnderstandClientParams, streamFactory: AudioUnderstandStreamFactory): AudioUnderstandResult;
 //# sourceMappingURL=audio-gen-result.d.ts.map

package/dist/src/client/api/audio-gen-result.js

@@ -1,4 +1,4 @@
-import { audioGenClientParamsSchema, audioGenStreamResponseSchema } from '@qvac/inference/surface';
+import { audioEditClientParamsSchema, audioEditStreamResponseSchema, audioGenClientParamsSchema, audioGenStreamResponseSchema, audioUnderstandClientParamsSchema, audioUnderstandResponseSchema } from '@qvac/inference/surface';
 import { parseClientInput } from '../parse-input.js';
 import { generateClientRequestId } from './client-request-id.js';
 import { decodeBase64 } from '../../utils/encoding.js';
@@ -22,21 +22,40 @@ export function createAudioGenResult(params, streamFactory) {
         type: 'audioGenStream',
         requestId
     };
+    return collectAudioRun(requestId, 'audioGenStream', audioGenStreamResponseSchema, () => streamFactory(request));
+}
+export function createAudioEditResult(params, streamFactory) {
+    const parsed = parseClientInput(audioEditClientParamsSchema, params);
+    const requestId = generateClientRequestId();
+    const request = {
+        ...parsed,
+        type: 'audioEditStream',
+        requestId
+    };
+    return collectAudioRun(requestId, 'audioEditStream', audioEditStreamResponseSchema, () => streamFactory(request));
+}
+export function createAudioUnderstandResult(params, streamFactory) {
+    const parsed = parseClientInput(audioUnderstandClientParamsSchema, params);
+    const requestId = generateClientRequestId();
+    const request = {
+        ...parsed,
+        type: 'audioUnderstand',
+        requestId
+    };
+    return collectUnderstandRun(requestId, () => streamFactory(request));
+}
+function collectRun(requestId, wireType, responseSchema, open, sink) {
     const progressQueue = [];
-    const pcmChunks = [];
-    let sampleRate;
-    let channels;
-    let bitsPerSample;
     let progressDone = false;
     let progressError;
     let progressResolve;
-    let resolveAudio = () => { };
-    let rejectAudio = () => { };
-    const audio = new Promise((resolve, reject) => {
-        resolveAudio = resolve;
-        rejectAudio = reject;
+    let resolvePayload = () => { };
+    let rejectPayload = () => { };
+    const payload = new Promise((resolve, reject) => {
+        resolvePayload = resolve;
+        rejectPayload = reject;
     });
-    audio.catch(() => { });
+    payload.catch(() => { });
     let resolveStats = () => { };
     let rejectStats = () => { };
     const stats = new Promise((resolve, reject) => {
@@ -55,60 +74,47 @@ export function createAudioGenResult(params, streamFactory) {
         progressResolve?.();
         progressResolve = undefined;
     }
+    function rejectAll(error) {
+        rejectPayload(error);
+        rejectStats(error);
+        rejectDiagnostics(error);
+    }
     async function processResponses() {
         let receivedDone = false;
         try {
-            for await (const response of streamFactory(request)) {
+            for await (const response of open()) {
                 if (!response ||
                     typeof response !== 'object' ||
                     !('type' in response) ||
-                    response.type !== 'audioGenStream') {
+                    response.type !== wireType) {
                     continue;
                 }
-                const chunk = audioGenStreamResponseSchema.parse(response);
-                if (chunk.progress) {
-                    progressQueue.push(chunk.progress);
+                const frame = responseSchema.parse(response);
+                if (frame.progress) {
+                    progressQueue.push(frame.progress);
                     notifyProgress();
                 }
-                if (chunk.data !== undefined) {
-                    pcmChunks.push(decodeBase64(chunk.data));
-                    sampleRate = chunk.sampleRate;
-                    channels = chunk.channels;
-                    bitsPerSample = chunk.bitsPerSample;
-                }
-                if (chunk.done) {
+                sink.absorb(frame);
+                if (frame.done) {
                     receivedDone = true;
-                    if (chunk.stopReason === 'cancelled') {
-                        const error = new InferenceCancelledError(requestId);
-                        rejectAudio(error);
-                        rejectStats(error);
-                        rejectDiagnostics(error);
+                    if (frame.stopReason === 'cancelled') {
+                        rejectAll(new InferenceCancelledError(requestId));
                         break;
                     }
-                    if (sampleRate === undefined || channels === undefined || bitsPerSample === undefined) {
-                        throw new InvalidResponseError('audioGenStream audio chunk');
-                    }
-                    resolveAudio({
-                        pcm: concatenateChunks(pcmChunks),
-                        sampleRate,
-                        channels,
-                        bitsPerSample
-                    });
-                    resolveStats(chunk.stats);
-                    resolveDiagnostics(chunk.diagnostics);
+                    const settled = sink.settle(frame);
+                    resolvePayload(settled);
+                    resolveStats(frame.stats);
+                    resolveDiagnostics(frame.diagnostics);
                     break;
                 }
             }
             if (!receivedDone) {
-                throw new InvalidResponseError('audioGenStream terminal response');
+                throw new InvalidResponseError(`${wireType} terminal response`);
             }
         }
         catch (error) {
-            progressError =
-                error instanceof Error ? error : new InvalidResponseError('audioGenStream', error);
-            rejectAudio(progressError);
-            rejectStats(progressError);
-            rejectDiagnostics(progressError);
+            progressError = error instanceof Error ? error : new InvalidResponseError(wireType, error);
+            rejectAll(progressError);
         }
         finally {
             progressDone = true;
@@ -133,11 +139,58 @@ export function createAudioGenResult(params, streamFactory) {
         }
     }
     void processResponses();
-    return {
-        requestId,
-        progressStream: progressStream(),
-        audio,
-        stats,
-        diagnostics
-    };
+    return { requestId, progressStream: progressStream(), payload, stats, diagnostics };
+}
+/**
+ * Consumes an `audioUnderstand()` stream: the engine streams the description
+ * as one `understand` item and repeats it on the terminal stats.
+ */
+function collectUnderstandRun(requestId, openStream) {
+    let seen;
+    const { progressStream, payload, stats, diagnostics } = collectRun(requestId, 'audioUnderstand', audioUnderstandResponseSchema, openStream, {
+        absorb(frame) {
+            if (frame.understand !== undefined)
+                seen = frame.understand;
+        },
+        settle(frame) {
+            const result = frame.stats?.understand ?? seen;
+            if (result === undefined) {
+                throw new InvalidResponseError('audioUnderstand description');
+            }
+            return result;
+        }
+    });
+    return { requestId, progressStream, description: payload, stats, diagnostics };
+}
+/**
+ * Consumes one generation or editing stream: PCM chunks accumulate into
+ * `audio`, carrying the format reported alongside them.
+ */
+function collectAudioRun(requestId, wireType, responseSchema, open) {
+    const pcmChunks = [];
+    let sampleRate;
+    let channels;
+    let bitsPerSample;
+    const { progressStream, payload, stats, diagnostics } = collectRun(requestId, wireType, responseSchema, open, {
+        absorb(frame) {
+            if (frame.data === undefined)
+                return;
+            pcmChunks.push(decodeBase64(frame.data));
+            sampleRate = frame.sampleRate;
+            channels = frame.channels;
+            bitsPerSample = frame.bitsPerSample;
+        },
+        settle() {
+            if (sampleRate === undefined || channels === undefined || bitsPerSample === undefined) {
+                throw new InvalidResponseError(`${wireType} audio chunk`);
+            }
+            return {
+                pcm: concatenateChunks(pcmChunks),
+                sampleRate,
+                channels,
+                bitsPerSample
+            };
+        }
+    });
+    return { requestId, progressStream, audio: payload, stats, diagnostics };
 }

package/dist/src/client/api/audio-gen.d.ts

@@ -3,6 +3,24 @@ import type { AudioGenClientParams, AudioGenResult } from '@qvac/inference/surfa
  * Generates PCM audio using a loaded AudioGen model.
  *
  * @param params - Loaded model ID, required caption, and optional lyrics, musical controls, duration, and seed.
+ * @param params.augmentCaptionWithMetadata - ACE-Step only: append BPM/tempo, time signature, and
+ *   key guidance to the internal conditioning caption (default `false`).
+ * @param params.audioCodes - ACE-Step only: frozen semantic codes (`Int32Array` or `number[]`)
+ *   to synthesize instead of running the LM.
+ * @param params.simpleMode - ACE-Step only: treat `caption` as a short query and let the LM compose
+ *   the full request. Requires `taskType: "text2music"`; mutually exclusive with `rewriteQuery`.
+ * @param params.rewriteQuery - ACE-Step only: the LM rewrites `caption` into a detailed description,
+ *   keeping the lyrics. Needs real `lyrics`, and `taskType: "text2music"`.
+ * @param params.generateLrc - ACE-Step only: return karaoke-style LRC in `stats.lrc` with an
+ *   alignment confidence in `stats.lyricsScore`. Needs lyrics, and `taskType: "text2music"`.
+ * @param params.computeQualityScore - ACE-Step only: report a weighted `[0, 1]` match of the codes
+ *   against the request in `stats.qualityScore`. Requires `taskType: "text2music"`.
+ * @param params.normalizeLoudness - ACE-Step only: percentile loudness normalization on the output
+ *   (default `true`). Set `false` for the raw engine output.
+ * @param params.guidanceScale - ACE-Step only: DiT classifier-free guidance scale; `0` (default)
+ *   resolves per DiT variant.
+ * @param params.track - ACE-Step only: the instrument layer the `"lego"` task regenerates.
+ *   Required when `taskType` is `"lego"` and rejected otherwise.
  * @param params.maxFrames - MiniMax semantic-frame cap; mutually exclusive with `duration`.
  * @param params.inferenceSteps - MiniMax flow steps for this run.
  * @param params.cfgScale - MiniMax flow classifier-free guidance scale for this run.
@@ -10,7 +28,7 @@ import type { AudioGenClientParams, AudioGenResult } from '@qvac/inference/surfa
  *   or raw interleaved stereo 48 kHz Float32 LE PCM bytes.
  * @param params.sourceAudio - Source audio to re-render (same forms as `referenceAudio`);
  *   required when `taskType` is `"cover-nofsq"`.
- * @param params.taskType - `"text2music"` (default) or `"cover-nofsq"`.
+ * @param params.taskType - `"text2music"` (default), `"cover-nofsq"`, or `"lego"`.
  * @param params.audioCoverStrength - Source-context strength for cover tasks (0..1).
  * @param params.coverNoiseStrength - Initial source/noise blend for cover tasks (0..1).
  * @returns A run with a synchronous request ID, generation progress stream, PCM audio promise, stats promise, and diagnostics promise describing the backend the run resolved to.
@@ -60,6 +78,25 @@ import type { AudioGenClientParams, AudioGenResult } from '@qvac/inference/surfa
  *   referenceAudio: "/path/to/reference.mp3",
  *   coverNoiseStrength: 0.75,
  * });
+ *
+ * // Let the LM expand a one-line query, and score and timestamp the take:
+ * const assisted = audioGen({
+ *   modelId,
+ *   caption: "a hopeful indie track for a road-trip montage",
+ *   simpleMode: true,
+ *   generateLrc: true,
+ *   computeQualityScore: true,
+ * });
+ * const { lrc, lyricsScore, qualityScore } = (await assisted.stats) ?? {};
+ *
+ * // Rebuild one layer of an existing song:
+ * const newDrums = audioGen({
+ *   modelId,
+ *   caption: "the same song with a busier, live-sounding kit",
+ *   taskType: "lego",
+ *   track: "drums",
+ *   sourceAudio: "/path/to/song.wav",
+ * });
  * ```
  */
 export declare function audioGen(params: AudioGenClientParams): AudioGenResult;

package/dist/src/client/api/audio-gen.js

@@ -4,6 +4,24 @@ import { createAudioGenResult } from './audio-gen-result.js';
  * Generates PCM audio using a loaded AudioGen model.
  *
  * @param params - Loaded model ID, required caption, and optional lyrics, musical controls, duration, and seed.
+ * @param params.augmentCaptionWithMetadata - ACE-Step only: append BPM/tempo, time signature, and
+ *   key guidance to the internal conditioning caption (default `false`).
+ * @param params.audioCodes - ACE-Step only: frozen semantic codes (`Int32Array` or `number[]`)
+ *   to synthesize instead of running the LM.
+ * @param params.simpleMode - ACE-Step only: treat `caption` as a short query and let the LM compose
+ *   the full request. Requires `taskType: "text2music"`; mutually exclusive with `rewriteQuery`.
+ * @param params.rewriteQuery - ACE-Step only: the LM rewrites `caption` into a detailed description,
+ *   keeping the lyrics. Needs real `lyrics`, and `taskType: "text2music"`.
+ * @param params.generateLrc - ACE-Step only: return karaoke-style LRC in `stats.lrc` with an
+ *   alignment confidence in `stats.lyricsScore`. Needs lyrics, and `taskType: "text2music"`.
+ * @param params.computeQualityScore - ACE-Step only: report a weighted `[0, 1]` match of the codes
+ *   against the request in `stats.qualityScore`. Requires `taskType: "text2music"`.
+ * @param params.normalizeLoudness - ACE-Step only: percentile loudness normalization on the output
+ *   (default `true`). Set `false` for the raw engine output.
+ * @param params.guidanceScale - ACE-Step only: DiT classifier-free guidance scale; `0` (default)
+ *   resolves per DiT variant.
+ * @param params.track - ACE-Step only: the instrument layer the `"lego"` task regenerates.
+ *   Required when `taskType` is `"lego"` and rejected otherwise.
  * @param params.maxFrames - MiniMax semantic-frame cap; mutually exclusive with `duration`.
  * @param params.inferenceSteps - MiniMax flow steps for this run.
  * @param params.cfgScale - MiniMax flow classifier-free guidance scale for this run.
@@ -11,7 +29,7 @@ import { createAudioGenResult } from './audio-gen-result.js';
  *   or raw interleaved stereo 48 kHz Float32 LE PCM bytes.
  * @param params.sourceAudio - Source audio to re-render (same forms as `referenceAudio`);
  *   required when `taskType` is `"cover-nofsq"`.
- * @param params.taskType - `"text2music"` (default) or `"cover-nofsq"`.
+ * @param params.taskType - `"text2music"` (default), `"cover-nofsq"`, or `"lego"`.
  * @param params.audioCoverStrength - Source-context strength for cover tasks (0..1).
  * @param params.coverNoiseStrength - Initial source/noise blend for cover tasks (0..1).
  * @returns A run with a synchronous request ID, generation progress stream, PCM audio promise, stats promise, and diagnostics promise describing the backend the run resolved to.
@@ -61,6 +79,25 @@ import { createAudioGenResult } from './audio-gen-result.js';
  *   referenceAudio: "/path/to/reference.mp3",
  *   coverNoiseStrength: 0.75,
  * });
+ *
+ * // Let the LM expand a one-line query, and score and timestamp the take:
+ * const assisted = audioGen({
+ *   modelId,
+ *   caption: "a hopeful indie track for a road-trip montage",
+ *   simpleMode: true,
+ *   generateLrc: true,
+ *   computeQualityScore: true,
+ * });
+ * const { lrc, lyricsScore, qualityScore } = (await assisted.stats) ?? {};
+ *
+ * // Rebuild one layer of an existing song:
+ * const newDrums = audioGen({
+ *   modelId,
+ *   caption: "the same song with a busier, live-sounding kit",
+ *   taskType: "lego",
+ *   track: "drums",
+ *   sourceAudio: "/path/to/song.wav",
+ * });
  * ```
  */
 export function audioGen(params) {

package/dist/src/client/api/audio-understand.d.ts

@@ -0,0 +1,25 @@
+import type { AudioUnderstandClientParams, AudioUnderstandResult } from '@qvac/inference/surface';
+/**
+ * Describes a recording with a loaded ACE-Step AudioGen model, running the
+ * engine's reverse pipeline: the PCM is encoded, its FSQ semantic codes are
+ * recovered, and the LM reports a caption and the clip's metadata.
+ *
+ * @param params - Loaded model ID, the source audio, and optional LM sampling controls.
+ * @param params.sourceAudio - The recording to analyse: a file path (decoded server-side) or raw
+ *   interleaved stereo 48 kHz Float32 LE PCM bytes in `[-1, 1]`.
+ * @param params.vocalLanguage - Language hint forced into the result instead of the LM's guess.
+ * @param params.seed - Seeds the LM decode; omit for a random seed.
+ * @returns A synchronous request ID, a progress stream, the `description` promise, and the stats and diagnostics promises.
+ *
+ * @example
+ * ```typescript
+ * const run = audioUnderstand({ modelId, sourceAudio: "/path/to/song.wav" });
+ * stopButton.onclick = () => cancel({ requestId: run.requestId });
+ * const { caption, bpm, keyscale, timesignature, audioCodes } = await run.description;
+ *
+ * // The recovered codes re-synthesize the same piece without re-running the LM.
+ * const remake = audioGen({ modelId, caption: "the same song, brighter mix", audioCodes });
+ * ```
+ */
+export declare function audioUnderstand(params: AudioUnderstandClientParams): AudioUnderstandResult;
+//# sourceMappingURL=audio-understand.d.ts.map

package/dist/src/client/api/audio-understand.js

@@ -0,0 +1,27 @@
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { createAudioUnderstandResult } from './audio-gen-result.js';
+/**
+ * Describes a recording with a loaded ACE-Step AudioGen model, running the
+ * engine's reverse pipeline: the PCM is encoded, its FSQ semantic codes are
+ * recovered, and the LM reports a caption and the clip's metadata.
+ *
+ * @param params - Loaded model ID, the source audio, and optional LM sampling controls.
+ * @param params.sourceAudio - The recording to analyse: a file path (decoded server-side) or raw
+ *   interleaved stereo 48 kHz Float32 LE PCM bytes in `[-1, 1]`.
+ * @param params.vocalLanguage - Language hint forced into the result instead of the LM's guess.
+ * @param params.seed - Seeds the LM decode; omit for a random seed.
+ * @returns A synchronous request ID, a progress stream, the `description` promise, and the stats and diagnostics promises.
+ *
+ * @example
+ * ```typescript
+ * const run = audioUnderstand({ modelId, sourceAudio: "/path/to/song.wav" });
+ * stopButton.onclick = () => cancel({ requestId: run.requestId });
+ * const { caption, bpm, keyscale, timesignature, audioCodes } = await run.description;
+ *
+ * // The recovered codes re-synthesize the same piece without re-running the LM.
+ * const remake = audioGen({ modelId, caption: "the same song, brighter mix", audioCodes });
+ * ```
+ */
+export function audioUnderstand(params) {
+    return createAudioUnderstandResult(params, streamRpc);
+}

package/dist/src/client/api/delete-cache.d.ts

@@ -2,7 +2,8 @@
  * Deletes KV cache files.
  *
  * @param params - The delete cache parameters
- * @param params.all - If true, deletes all cache files
+ * @param params.all - If true, deletes all cache files, including caller-owned named caches
+ * @param params.auto - If true, reclaims only automatic caches (`completion({ kvCache: true })`) that no request is using. Named caches are untouched. Covers the whole cache directory, which is shared by every QVAC process using the same home directory
  * @param params.kvCacheKey - The cache key to delete
  * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
  * @returns Promise resolving to success status
@@ -12,6 +13,9 @@
  * // Delete all caches
  * await deleteCache({ all: true });
  *
+ * // Reclaim disk from automatic caches, leaving named caches alone
+ * await deleteCache({ auto: true });
+ *
  * // Delete entire cache key (all models)
  * await deleteCache({ kvCacheKey: "my-session" });
  *
@@ -21,6 +25,8 @@
  */
 export declare function deleteCache(params: {
     all: true;
+} | {
+    auto: true;
 } | {
     kvCacheKey: string;
     modelId?: string;

package/dist/src/client/api/delete-cache.js

@@ -4,7 +4,8 @@ import { InvalidDeleteCacheParamsError, DeleteCacheFailedError } from '../../uti
  * Deletes KV cache files.
  *
  * @param params - The delete cache parameters
- * @param params.all - If true, deletes all cache files
+ * @param params.all - If true, deletes all cache files, including caller-owned named caches
+ * @param params.auto - If true, reclaims only automatic caches (`completion({ kvCache: true })`) that no request is using. Named caches are untouched. Covers the whole cache directory, which is shared by every QVAC process using the same home directory
  * @param params.kvCacheKey - The cache key to delete
  * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
  * @returns Promise resolving to success status
@@ -14,6 +15,9 @@ import { InvalidDeleteCacheParamsError, DeleteCacheFailedError } from '../../uti
  * // Delete all caches
  * await deleteCache({ all: true });
  *
+ * // Reclaim disk from automatic caches, leaving named caches alone
+ * await deleteCache({ auto: true });
+ *
  * // Delete entire cache key (all models)
  * await deleteCache({ kvCacheKey: "my-session" });
  *
@@ -29,6 +33,12 @@ export async function deleteCache(params) {
             all: true
         };
     }
+    else if ('auto' in params && params.auto) {
+        req = {
+            type: 'deleteCache',
+            auto: true
+        };
+    }
     else if ('kvCacheKey' in params) {
         req = {
             type: 'deleteCache',

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

@@ -14,6 +14,7 @@ export { finetune, type FinetuneHandle } from './finetune.js';
 export { translate } from './translate.js';
 export { cancel } from './cancel.js';
 export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace } from './rag.js';
+export { createVectorIndex, loadVectorIndex, type VectorIndex } from './vector-index.js';
 export { textToSpeech, textToSpeechStream } from './text-to-speech.js';
 export { getModelInfo } from './get-model-info.js';
 export { getLoadedModelInfo } from './get-loaded-model-info.js';
@@ -34,4 +35,6 @@ export { state } from './state.js';
 export { vla, vlaHparams, vlaSetEmbodiment } from './vla.js';
 export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-helpers.js';
 export { audioGen } from './audio-gen.js';
+export { audioEdit } from './audio-edit.js';
+export { audioUnderstand } from './audio-understand.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -14,6 +14,7 @@ export { finetune } from './finetune.js';
 export { translate } from './translate.js';
 export { cancel } from './cancel.js';
 export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace } from './rag.js';
+export { createVectorIndex, loadVectorIndex } from './vector-index.js';
 export { textToSpeech, textToSpeechStream } from './text-to-speech.js';
 export { getModelInfo } from './get-model-info.js';
 export { getLoadedModelInfo } from './get-loaded-model-info.js';
@@ -34,3 +35,5 @@ export { state } from './state.js';
 export { vla, vlaHparams, vlaSetEmbodiment } from './vla.js';
 export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-helpers.js';
 export { audioGen } from './audio-gen.js';
+export { audioEdit } from './audio-edit.js';
+export { audioUnderstand } from './audio-understand.js';

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

@@ -1,4 +1,4 @@
-import { type TtsClientParamsInput, type RPCOptions, type TtsResponse, type TextToSpeechStreamClientParams, type TextToSpeechStreamSession, type TextToSpeechStreamResult } from '@qvac/inference/surface';
+import { type TtsClientParamsInput, type RPCOptions, type TtsResponse, type TextToSpeechStreamClientParams, type TextToSpeechStreamSession, type TextToSpeechStreamResult, type TtsStats } from '@qvac/inference/surface';
 /**
  * Fan-out queue that lets multiple consumers iterate the same TTS response
  * stream independently. Items are retained only until every active subscriber
@@ -33,9 +33,9 @@ export declare class TtsMulticast {
  *
  * Three modes selected by `params.stream` and `params.sentenceStream`:
  *
- * - `stream: false` (default) — collect all PCM samples and resolve once via
+ * - `stream: false` — collect all PCM samples and resolve once via
  *   `result.buffer` (`Promise<number[]>`). `bufferStream` is empty.
- * - `stream: true` — yield PCM samples through `result.bufferStream`
+ * - `stream: true` (default) — yield PCM samples through `result.bufferStream`
  *   (`AsyncGenerator<number>`) as they arrive. `buffer` resolves to an empty
  *   array.
  * - `stream: true, sentenceStream: true` — also exposes `result.chunkUpdates`
@@ -47,14 +47,41 @@ export declare class TtsMulticast {
  * 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.
  *
+ * `result.sampleRate` resolves from the first audio frame (so it can be awaited
+ * before draining the audio); `result.stats` and `result.stopReason` resolve
+ * from the terminal frame. All three resolve — with `undefined` when the run
+ * produced none — rather than reject. In `stream: true` mode (the default) the
+ * run starts lazily: nothing is sent until `bufferStream` is first iterated, so
+ * `done`, `sampleRate`, `stats` and `stopReason` stay pending until then. In
+ * `stream: false` and `sentenceStream: true` modes the run starts immediately.
+ * Read `sampleRate` rather than assuming the engine default: `outputSampleRate`
+ * and the LavaSR enhancer both change it.
+ *
  * @param params - TTS request parameters (see `TtsClientParamsInput`).
  * @param options - Optional RPC options (timeout, profiling, force new connection).
  * @returns A `TextToSpeechStreamResult` with `bufferStream`, `buffer`, `done`,
- *          and (when `sentenceStream: true`) `chunkUpdates`.
+ *          `sampleRate`, `stats`, and (when `sentenceStream: true`)
+ *          `chunkUpdates`.
  * @throws {TextToSpeechStreamFailedError} When `sentenceStream: true` is paired
  *         with `stream: false`, or when the underlying RPC stream errors.
  */
 export declare function textToSpeech(params: TtsClientParamsInput, options?: RPCOptions): TextToSpeechStreamResult;
+/**
+ * The output rate and the runtime stats ride the response frames, but the
+ * three result shapes below expose PCM through generators a caller may abandon
+ * early. This collects both off the frames as they pass and hands them back as
+ * promises that always RESOLVE — with `undefined` when the run produced none —
+ * so `await result.sampleRate` can never hang or reject on its own.
+ */
+export type TtsSideChannel = {
+    sampleRate: Promise<number | undefined>;
+    stats: Promise<TtsStats | undefined>;
+    stopReason: Promise<'completed' | 'cancelled' | undefined>;
+    observe(response: TtsResponse): void;
+    settle(): void;
+};
+/** Exported for test use; not part of the public SDK surface. */
+export declare function createTtsSideChannel(): TtsSideChannel;
 export declare function encodeTextToSpeechFragment(textFragment: string | Uint8Array): Uint8Array<ArrayBufferLike>;
 /**
  * Duplex session: write UTF-8 text fragments (e.g. LLM token deltas) via `write`. Each string or